ML for Drug Discovery - Part2.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "24622c3b",
      "metadata": {
        "id": "24622c3b"
      },
      "source": [
        "# **Exploratory Data Analysis**\n",
        "In part 1, we mainly stayed focused to generate a dataset with certain key features or standard_type (IC50). In this section we will use the generated data and to generate or to fix molecular descriptors present in the chemical structures. After successful generation, we will perform some analysis, to what we call Exploratory Data Analysis. I highly acknowledge and refer materials of Dr. Chanin Nantasenamat an Associate professor in Bioinformatics.\n",
        "So Let's Move.\n",
        "This Notebook is created by **Dr. Ashfaq Ahmad**"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4471a1f4",
      "metadata": {
        "id": "4471a1f4"
      },
      "source": [
        "### **Install Conda and rdkit**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1410197b",
      "metadata": {
        "id": "1410197b"
      },
      "outputs": [],
      "source": [
        "! wget https://repo.anaconda.com/miniconda/Miniconda3-py37_4.8.2-Linux-x86_64.sh\n",
        "! chmod +x Miniconda3-py37_4.8.2-Linux-x86_64.sh\n",
        "! bash ./Miniconda3-py37_4.8.2-Linux-x86_64.sh -b -f -p /usr/local\n",
        "! conda install -c rdkit rdkit -y\n",
        "import sys\n",
        "sys.path.append('/usr/local/lib/python3.7/site-packages/')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "a6d4ae1b",
      "metadata": {
        "id": "a6d4ae1b"
      },
      "outputs": [],
      "source": [
        "import pandas as pd"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c85c0d7b",
      "metadata": {
        "id": "c85c0d7b"
      },
      "source": [
        "### **Step 1 - Loading (Bioactivity Data) Generated in Part-1**\n",
        "\n",
        "To upload your file, run the following cell. You will be promted to upload your datafile, already prepared and saved in CSV formate."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "b909b81f",
      "metadata": {
        "id": "b909b81f",
        "outputId": "12619150-d7ac-4fdf-995e-ec6a31d115fc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 73
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-de23eab8-df31-4edd-a5b4-11c16800aa5a\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-de23eab8-df31-4edd-a5b4-11c16800aa5a\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving P2Y1_03_bioactivity_data_curated.csv to P2Y1_03_bioactivity_data_curated.csv\n"
          ]
        }
      ],
      "source": [
        "from google.colab import files\n",
        "uploaded = files.upload()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "id": "9fcd3160",
      "metadata": {
        "id": "9fcd3160"
      },
      "outputs": [],
      "source": [
        "df = pd.read_csv('P2Y1_03_bioactivity_data_curated.csv')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1febc9e1",
      "metadata": {
        "id": "1febc9e1"
      },
      "outputs": [],
      "source": [
        "df"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "6555ac1c",
      "metadata": {
        "id": "6555ac1c"
      },
      "outputs": [],
      "source": [
        "df_no_smiles = df.drop(columns='canonical_smiles')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "id": "58c073c1",
      "metadata": {
        "id": "58c073c1"
      },
      "outputs": [],
      "source": [
        "smiles = []\n",
        "\n",
        "for i in df.canonical_smiles.tolist():\n",
        "  cpd = str(i).split('.')\n",
        "  cpd_longest = max(cpd, key = len)\n",
        "  smiles.append(cpd_longest)\n",
        "\n",
        "smiles = pd.Series(smiles, name = 'canonical_smiles')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7432c20e",
      "metadata": {
        "id": "7432c20e"
      },
      "outputs": [],
      "source": [
        "df_clean_smiles = pd.concat([df_no_smiles,smiles], axis=1)\n",
        "df_clean_smiles"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "27dc5f5d",
      "metadata": {
        "id": "27dc5f5d"
      },
      "source": [
        "### **Step 2 - Calculations of Lipinski Descriptors**\n",
        "What are Lipinski rules or Descriptors?\n",
        "\n",
        "A Pfizer scientist, Christopher Lipinski, designed a bunch of rules in evaluating a chemical compound for **druglikeness**. Lipinski analyzed these rules after studying vaste number of FDA-approved drugs in the formulation. In Simple terms, druglikeness is primarily based on the drug Absorption, Distribution, Metabolism and Excretion (ADME) that is also known as the pharmacokinetic profile. Lipinski rules are normally known as  **Rule-of-Five** or **Lipinski's Rule**.\n",
        "\n",
        "The Lipinski's Rule states,\n",
        "* Molecular weight < 500 Dalton\n",
        "* Octanol-water partition coefficient (LogP) < 5\n",
        "* Hydrogen bond donors < 5\n",
        "* Hydrogen bond acceptors < 10"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cd8e5e4a",
      "metadata": {
        "id": "cd8e5e4a"
      },
      "source": [
        "### **Import essential libraries to the workspace**"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install rdkit"
      ],
      "metadata": {
        "id": "yiifs3vDFI7l"
      },
      "id": "yiifs3vDFI7l",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "id": "06e18cb0",
      "metadata": {
        "id": "06e18cb0"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from rdkit import Chem\n",
        "from rdkit.Chem import Descriptors, Lipinski"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e1848c24",
      "metadata": {
        "id": "e1848c24"
      },
      "source": [
        "**Now we are in a position to calculate Lipinski descriptors**"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e3095d7a",
      "metadata": {
        "id": "e3095d7a"
      },
      "source": [
        "### **Step 3 - Calculation of Lipinski Descriptors**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "id": "810b2521",
      "metadata": {
        "id": "810b2521"
      },
      "outputs": [],
      "source": [
        "# Inspired by: https://codeocean.com/explore/capsules?query=tag:data-curation\n",
        "\n",
        "def lipinski(smiles, verbose=False):\n",
        "\n",
        "    moldata= []\n",
        "    for elem in smiles:\n",
        "        mol=Chem.MolFromSmiles(elem)\n",
        "        moldata.append(mol)\n",
        "\n",
        "    baseData= np.arange(1,1)\n",
        "    i=0\n",
        "    for mol in moldata:\n",
        "\n",
        "        desc_MolWt = Descriptors.MolWt(mol)\n",
        "        desc_MolLogP = Descriptors.MolLogP(mol)\n",
        "        desc_NumHDonors = Lipinski.NumHDonors(mol)\n",
        "        desc_NumHAcceptors = Lipinski.NumHAcceptors(mol)\n",
        "\n",
        "        row = np.array([desc_MolWt,\n",
        "                        desc_MolLogP,\n",
        "                        desc_NumHDonors,\n",
        "                        desc_NumHAcceptors])\n",
        "\n",
        "        if(i==0):\n",
        "            baseData=row\n",
        "        else:\n",
        "            baseData=np.vstack([baseData, row])\n",
        "        i=i+1\n",
        "\n",
        "    columnNames=[\"MW\",\"LogP\",\"NumHDonors\",\"NumHAcceptors\"]\n",
        "    descriptors = pd.DataFrame(data=baseData,columns=columnNames)\n",
        "\n",
        "    return descriptors"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "id": "3a66cb89",
      "metadata": {
        "id": "3a66cb89"
      },
      "outputs": [],
      "source": [
        "df_lipinski = lipinski(df_clean_smiles.canonical_smiles)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4cbd2cd6",
      "metadata": {
        "id": "4cbd2cd6"
      },
      "outputs": [],
      "source": [
        "df_lipinski"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f8bd01b0",
      "metadata": {
        "id": "f8bd01b0"
      },
      "source": [
        "So far we have two dataframes, the df_lipinski and the df. We need to combine both these two frames into a single frame. If you want to see, these two frames, run the two cells below."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c99cad32",
      "metadata": {
        "id": "c99cad32"
      },
      "outputs": [],
      "source": [
        "df_lipinski"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8fdff769",
      "metadata": {
        "id": "8fdff769"
      },
      "outputs": [],
      "source": [
        "df"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "59e9bce4",
      "metadata": {
        "id": "59e9bce4"
      },
      "source": [
        "Lets Combine"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "id": "b3282f38",
      "metadata": {
        "id": "b3282f38"
      },
      "outputs": [],
      "source": [
        "df_combined = pd.concat([df,df_lipinski], axis=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "83a9405f",
      "metadata": {
        "id": "83a9405f"
      },
      "outputs": [],
      "source": [
        "df_combined"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "238ee9b3",
      "metadata": {
        "id": "238ee9b3"
      },
      "source": [
        "### **Step 4 - Convert IC50 to pIC50**\n",
        "The **IC50** values are normally too much diverse therefore we need to the data to be more uniformly distributed, and for the reason we will convert **IC50** to the negative logarithmic scale which is essentially **-log10(IC50)** or **pIC50**\n",
        "\n",
        "Next we will use the custom function pIC50() which will accept a DataFrame as input and will output,\n",
        "* Take the IC50 values from the ``standard_value`` column and converts it from nM (nanoMolar) to M (molar) concentration by multiplying the value by 10$^{-9}$\n",
        "* Take the molar value and apply -log10\n",
        "* Delete the ``standard_value`` column and create a new ``pIC50`` column.\n",
        "\n",
        "Point to note: These calculations will also normalize the data and values greater than 100,000,000 will be fixed at 100,000,000 otherwise the negative logarithmic value will become negative."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "id": "4bc39b24",
      "metadata": {
        "id": "4bc39b24"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "\n",
        "def pIC50(input):\n",
        "    pIC50 = []\n",
        "\n",
        "    for i in input['standard_value_norm']:\n",
        "        molar = i*(10**-9) # Converts nM to M\n",
        "        pIC50.append(-np.log10(molar))\n",
        "\n",
        "    input['pIC50'] = pIC50\n",
        "    x = input.drop('standard_value_norm', 1)\n",
        "\n",
        "    return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d27ab87d",
      "metadata": {
        "id": "d27ab87d"
      },
      "outputs": [],
      "source": [
        "df_combined.standard_value.describe()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1758b929",
      "metadata": {
        "id": "1758b929"
      },
      "outputs": [],
      "source": [
        "-np.log10( (10**-9)* 100000000 )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1ac5d7e1",
      "metadata": {
        "id": "1ac5d7e1"
      },
      "outputs": [],
      "source": [
        "-np.log10( (10**-9)* 10000000000 )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "id": "0bc3730b",
      "metadata": {
        "id": "0bc3730b"
      },
      "outputs": [],
      "source": [
        "def norm_value(input):\n",
        "    norm = []\n",
        "\n",
        "    for i in input['standard_value']:\n",
        "        if i > 100000000:\n",
        "          i = 100000000\n",
        "        norm.append(i)\n",
        "\n",
        "    input['standard_value_norm'] = norm\n",
        "    x = input.drop('standard_value', 1)\n",
        "\n",
        "    return x"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Normalization function\n",
        "def norm_value(input_df):\n",
        "    # Normalize the 'standard_value' column\n",
        "    norm = (input_df['standard_value'] - input_df['standard_value'].min()) / (input_df['standard_value'].max() - input_df['standard_value'].min())\n",
        "    input_df['standard_value_norm'] = norm\n",
        "    x = input_df.drop('standard_value', axis=1)\n",
        "    return x\n",
        "\n",
        "# Assuming df_combined is already loaded\n",
        "df_norm = norm_value(df_combined)\n",
        "print(df_norm)"
      ],
      "metadata": {
        "id": "SHt0z4MlF0ZW"
      },
      "id": "SHt0z4MlF0ZW",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9dc1e5cd",
      "metadata": {
        "id": "9dc1e5cd"
      },
      "outputs": [],
      "source": [
        "df_norm"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d220be41",
      "metadata": {
        "id": "d220be41"
      },
      "outputs": [],
      "source": [
        "df_norm.standard_value_norm.describe()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Function to calculate pIC50 values\n",
        "def pIC50(input_df):\n",
        "    # Assuming we are calculating pIC50 using the normalized values\n",
        "    input_df['pIC50'] = -np.log10(input_df['standard_value_norm'] * 1e-9)  # Example transformation\n",
        "    return input_df\n",
        "\n",
        "# Assuming df_norm is already created\n",
        "df_final = pIC50(df_norm)\n",
        "print(df_final)"
      ],
      "metadata": {
        "id": "gvv6UySKHjgd"
      },
      "id": "gvv6UySKHjgd",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9ab8fc3a",
      "metadata": {
        "id": "9ab8fc3a"
      },
      "outputs": [],
      "source": [
        "df_final"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2ac381bb",
      "metadata": {
        "id": "2ac381bb"
      },
      "outputs": [],
      "source": [
        "df_final.pIC50.describe()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0c4b8204",
      "metadata": {
        "id": "0c4b8204"
      },
      "source": [
        "Now, we are in a position to save our data into CSV file"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "id": "89b3947f",
      "metadata": {
        "id": "89b3947f"
      },
      "outputs": [],
      "source": [
        "df_final.to_csv('P2Y1_04_bioactivity_data_3class_pIC50.csv')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "79261e74",
      "metadata": {
        "id": "79261e74"
      },
      "source": [
        "### **Step 5 - Removal of the intermediate class from the whole data**\n",
        "Here we are going to drop the compounds with intermediate bioactivity. We will drop them because we want to compare the active and inactive class."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "dcd48e5b",
      "metadata": {
        "id": "dcd48e5b"
      },
      "outputs": [],
      "source": [
        "df_2class = df_final[df_final['class'] != 'intermediate']\n",
        "df_2class"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bc84430a",
      "metadata": {
        "id": "bc84430a"
      },
      "source": [
        "Write results to the CSV file"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "id": "fb61e2ac",
      "metadata": {
        "id": "fb61e2ac"
      },
      "outputs": [],
      "source": [
        "df_2class.to_csv('P2Y1_05_bioactivity_data_2class_pIC50.csv')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f0d7ccbf",
      "metadata": {
        "id": "f0d7ccbf"
      },
      "source": [
        "## **Exploratory Data Analysis OR Chemical Space Analysis through Lipinski descriptors**"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2e79b602",
      "metadata": {
        "id": "2e79b602"
      },
      "source": [
        "### **Step 6 - Import Essential Libraries**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "id": "e8fd8d13",
      "metadata": {
        "id": "e8fd8d13"
      },
      "outputs": [],
      "source": [
        "import seaborn as sns\n",
        "sns.set(style='ticks')\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "25f797ee",
      "metadata": {
        "id": "25f797ee"
      },
      "source": [
        "### **Analysis of Frequency plot of the two bioactivity classes**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "id": "82807f8d",
      "metadata": {
        "id": "82807f8d",
        "outputId": "ca539e71-e5c2-4411-95a5-56e5e7e86003",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 530
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Frequency')"
            ]
          },
          "metadata": {},
          "execution_count": 39
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 550x550 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plt.figure(figsize=(5.5, 5.5))\n",
        "\n",
        "sns.countplot(x='class', data=df_2class, edgecolor='black')\n",
        "\n",
        "plt.xlabel('Bioactivity class', fontsize=14, fontweight='bold')\n",
        "plt.ylabel('Frequency', fontsize=14, fontweight='bold')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "311b2089",
      "metadata": {
        "id": "311b2089"
      },
      "outputs": [],
      "source": [
        "plt.savefig('plot_bioactivity_class.pdf')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c8b4a8a8",
      "metadata": {
        "id": "c8b4a8a8"
      },
      "source": [
        "### **Scatter plot of Molecular Weight (MW) versus LogP (Solubility)**\n",
        "\n",
        "It can be seen that the 2 bioactivity classes are not taking or spanning a kind of similar chemical spaces as evident by the scatter plot of MW vs LogP.\n",
        "In below function, **x** and **y** are for the legends on these axis. **data** means, data to be plotted. **hue** represents the coloring scheme, and here we are interested to be based on the bioactivity class. **size** are for the sphere size and will be proportional to the pIC50 value. sphere **edges** will be black and transperancy threshould or *alpha* of the picture is 0.7. You can adjusted if required."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "51c91941",
      "metadata": {
        "id": "51c91941"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(5.5, 5.5))\n",
        "\n",
        "sns.scatterplot(x='MW', y='LogP', data=df_2class, hue='class', size='pIC50', edgecolor='black', alpha=0.7)\n",
        "\n",
        "plt.xlabel('MW', fontsize=14, fontweight='bold')\n",
        "plt.ylabel('LogP', fontsize=14, fontweight='bold')\n",
        "plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0)\n",
        "plt.savefig('plot_MW_vs_LogP.pdf')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "665facb5",
      "metadata": {
        "id": "665facb5"
      },
      "source": [
        "### **Box plots**\n",
        "Lets do some calculations with Box plot"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1c6f1789",
      "metadata": {
        "id": "1c6f1789"
      },
      "source": [
        "#### **pIC50 value**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1bdd28a5",
      "metadata": {
        "id": "1bdd28a5"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(5.5, 5.5))\n",
        "\n",
        "sns.boxplot(x = 'class', y = 'pIC50', data = df_2class)\n",
        "\n",
        "plt.xlabel('Bioactivity class', fontsize=14, fontweight='bold')\n",
        "plt.ylabel('pIC50 value', fontsize=14, fontweight='bold')\n",
        "\n",
        "plt.savefig('plot_IC50.pdf')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3daec45d",
      "metadata": {
        "id": "3daec45d"
      },
      "source": [
        "### **Statistical analysis | Mann-Whitney U Test**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "eadee1d3",
      "metadata": {
        "id": "eadee1d3"
      },
      "outputs": [],
      "source": [
        "def mannwhitney(descriptor, verbose=False):\n",
        "  # https://machinelearningmastery.com/nonparametric-statistical-significance-tests-in-python/\n",
        "  from numpy.random import seed\n",
        "  from numpy.random import randn\n",
        "  from scipy.stats import mannwhitneyu\n",
        "\n",
        "# seed the random number generator\n",
        "  seed(1)\n",
        "\n",
        "# actives and inactives\n",
        "  selection = [descriptor, 'class']\n",
        "  df = df_2class[selection]\n",
        "  active = df[df['class'] == 'active']\n",
        "  active = active[descriptor]\n",
        "\n",
        "  selection = [descriptor, 'class']\n",
        "  df = df_2class[selection]\n",
        "  inactive = df[df['class'] == 'inactive']\n",
        "  inactive = inactive[descriptor]\n",
        "\n",
        "# compare samples\n",
        "  stat, p = mannwhitneyu(active, inactive)\n",
        "  #print('Statistics=%.3f, p=%.3f' % (stat, p))\n",
        "\n",
        "# interpret\n",
        "  alpha = 0.05\n",
        "  if p > alpha:\n",
        "    interpretation = 'Same distribution (fail to reject H0)'\n",
        "  else:\n",
        "    interpretation = 'Different distribution (reject H0)'\n",
        "\n",
        "  results = pd.DataFrame({'Descriptor':descriptor,\n",
        "                          'Statistics':stat,\n",
        "                          'p':p,\n",
        "                          'alpha':alpha,\n",
        "                          'Interpretation':interpretation}, index=[0])\n",
        "  filename = 'mannwhitneyu_' + descriptor + '.csv'\n",
        "  results.to_csv(filename)\n",
        "\n",
        "  return results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3530055a",
      "metadata": {
        "id": "3530055a"
      },
      "outputs": [],
      "source": [
        "mannwhitney('pIC50')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "402c7ceb",
      "metadata": {
        "id": "402c7ceb"
      },
      "source": [
        "#### **Molecular Weight (MW)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "abbdaa0b",
      "metadata": {
        "id": "abbdaa0b"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(5.5, 5.5))\n",
        "\n",
        "sns.boxplot(x = 'class', y = 'MW', data = df_2class)\n",
        "\n",
        "plt.xlabel('Bioactivity class', fontsize=14, fontweight='bold')\n",
        "plt.ylabel('MW', fontsize=14, fontweight='bold')\n",
        "\n",
        "plt.savefig('plot_MW.pdf')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cea4b429",
      "metadata": {
        "id": "cea4b429"
      },
      "outputs": [],
      "source": [
        "mannwhitney('MW')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0329bcd5",
      "metadata": {
        "id": "0329bcd5"
      },
      "source": [
        "#### **LogP or Solubility**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d2088ef2",
      "metadata": {
        "id": "d2088ef2"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(5.5, 5.5))\n",
        "\n",
        "sns.boxplot(x = 'class', y = 'LogP', data = df_2class)\n",
        "\n",
        "plt.xlabel('Bioactivity class', fontsize=14, fontweight='bold')\n",
        "plt.ylabel('LogP', fontsize=14, fontweight='bold')\n",
        "\n",
        "plt.savefig('plot_LogP.pdf')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f55bc982",
      "metadata": {
        "id": "f55bc982"
      },
      "outputs": [],
      "source": [
        "mannwhitney('LogP')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "743d008b",
      "metadata": {
        "id": "743d008b"
      },
      "source": [
        "#### **NumHDonors or H-bond Donor**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c9cfb2d7",
      "metadata": {
        "id": "c9cfb2d7"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(5.5, 5.5))\n",
        "\n",
        "sns.boxplot(x = 'class', y = 'NumHDonors', data = df_2class)\n",
        "\n",
        "plt.xlabel('Bioactivity class', fontsize=14, fontweight='bold')\n",
        "plt.ylabel('NumHDonors', fontsize=14, fontweight='bold')\n",
        "\n",
        "plt.savefig('plot_NumHDonors.pdf')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d22014fd",
      "metadata": {
        "id": "d22014fd"
      },
      "outputs": [],
      "source": [
        "mannwhitney('NumHDonors')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ad30328c",
      "metadata": {
        "id": "ad30328c"
      },
      "source": [
        "#### **NumHAcceptors or H-bond Acceptor**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "040d0ebc",
      "metadata": {
        "id": "040d0ebc"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(5.5, 5.5))\n",
        "\n",
        "sns.boxplot(x = 'class', y = 'NumHAcceptors', data = df_2class)\n",
        "\n",
        "plt.xlabel('Bioactivity class', fontsize=14, fontweight='bold')\n",
        "plt.ylabel('NumHAcceptors', fontsize=14, fontweight='bold')\n",
        "\n",
        "plt.savefig('plot_NumHAcceptors.pdf')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "44cd3b1c",
      "metadata": {
        "id": "44cd3b1c"
      },
      "outputs": [],
      "source": [
        "mannwhitney('NumHAcceptors')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "55d9c3cc",
      "metadata": {
        "id": "55d9c3cc"
      },
      "source": [
        "### **Interpretation of the Statistical Results**\n",
        "\n",
        "In the final part we have run Mannwhitney U test. The Mann-Whitney U test is used to compare differences between two independent groups when the dependent variable is either ordinal or continuous, but not normally distributed.\n",
        "\n",
        "The p-value is a probability that measures the evidence against the null hypothesis. A smaller p-value provides stronger evidence against the null hypothesis."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cc59a0c4",
      "metadata": {
        "id": "cc59a0c4"
      },
      "source": [
        "#### **Download these results as a Zip files**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3336b726",
      "metadata": {
        "id": "3336b726"
      },
      "outputs": [],
      "source": [
        "! zip -r Drug_Designing_Part2.zip . -i *.csv *.pdf"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.9"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}