Ridge_CDK2_Ki_MVD.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# **Ridge Regression for the CDK2 K<sub>i</sub> Dataset Generated with Molegro Virtual Docker**\n",
        "\n",
        "This Jupyter Notebook builds a regression model using the Ridge method (also known as Tikhonov regularization) ([Tikhonov, 1963](https://scholar.google.com/scholar?q=A.+N.+Tikhonov,+Solution+of+incorrectly+formulated+problems+and+the+regularization+method); [Géron, 2023](https://www.isbns.net/isbn/9781098125974/)) for data from the CDK2 K<sub>i</sub> dataset ([de Azevedo et al., 2024](https://doi.org/10.1002/jcc.27449)). This dataset employs the ligands described for case study 1 on the SAnDReS 2.0 paper ([de Azevedo et al., 2024](https://doi.org/10.1002/jcc.27449)) but with energy terms and poses determined using Molegro Virtual Docker (MVD) ([Thomsen & Christensen, 2006](https://doi.org/10.1021/jm051197e)). MVD employed differential evolution ([Storn & Price, 1997](https://doi.org/10.1023/A:1008202821328)) as a search algorithm and MolDock Score to estimate binding affinity. This code used the [Ridge](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html) class ([Tikhonov, 1963](https://scholar.google.com/scholar?q=A.+N.+Tikhonov,+Solution+of+incorrectly+formulated+problems+and+the+regularization+method)) from the [Scikit-Learn](https://scikit-learn.org/stable/) library ([Pedregosa et al., 2011](https://doi.org/10.48550/arXiv.1201.0490)) to generate the regression model. It evaluates the model's predictive performance using metrics recommended by [Walsh et al., 2021](https://doi.org/10.1038/s41592-021-01205-4) and [de Azevedo et al., 2024](https://doi.org/10.1002/jcc.27449).\n",
        "<br> </br>\n",
        "<img src=\"https://drive.usercontent.google.com/download?id=1P9cUrTTjl5wAj-Q_jirIQ8opRoQ5c9ja&export=view&authuser=0\" width=600 alt=\"PDB: 2A4L\">\n",
        "<br><i>Structure of a protein-ligand complex ([de Azevedo et al., 1997](https://doi.org/10.1111/j.1432-1033.1997.0518a.x)) with an inhibitor bound to the macromolecule (PDB access code: [2A4L](https://www.rcsb.org/structure/2A4L)).</i></br>\n",
        "<br></br>\n",
        "**References**\n",
        "<br></br>\n",
        "de Azevedo WF, Leclerc S, Meijer L, Havlicek L, Strnad M, Kim SH. Inhibition of cyclin-dependent kinases by purine analogues: crystal structure of human cdk2 complexed with roscovitine. Eur J Biochem. 1997; 243(1-2): 518-26.\n",
        "PMID: 9030780.\n",
        "[DOI: 10.1111/j.1432-1033.1997.0518a.x](https://doi.org/10.1111/j.1432-1033.1997.0518a.x)\n",
        "<br></br>\n",
        "de Azevedo WF Jr, Quiroga R, Villarreal MA, da Silveira NJF, Bitencourt-Ferreira G, da Silva AD, Veit-Acosta M, Oliveira PR, Tutone M, Biziukova N, Poroikov V, Tarasova O, Baud S. SAnDReS 2.0: Development of machine-learning models to explore the scoring function space. J Comput Chem. 2024; 45(27): 2333-2346. PMID: 38900052. [DOI: 10.1002/jcc.27449](https://doi.org/10.1002/jcc.27449) [PubMed](https://pubmed.ncbi.nlm.nih.gov/38900052/)\n",
        "<br></br>\n",
        "Géron, A. Hands-on Machine Learning with Scikit-Learn, Keras, and TensorFlow 3e: Concepts, Tools, and Techniques to Build Intelligent Systems, 3rd ed.; O’Reilly Media: Sebastopol, CA, 2023.\n",
        "[ISBN: 978-1-098-12597-4](https://www.isbns.net/isbn/9781098125974/)\n",
        "<br></br>\n",
        "Pedregosa F, Varoquaux G, Gramfort A, Michel V, Thirion B, Grisel O, Blondel M, Prettenhofer P, Weiss R, Dubourg V, Verplas J, Passos A, Cournapeau D, Brucher M, Perrot M, Duchesnay E. Scikitlearn: Machine Learning in Python. J Mach Learn Res., 2011; 12:2825–2830. [DOI: 10.48550/arXiv.1201.0490](https://doi.org/10.48550/arXiv.1201.0490)\n",
        "<br></br>\n",
        "Thomsen R, Christensen MH. MolDock: a new technique for high-accuracy molecular docking. J Med Chem. 2006; 49(11): 3315-21. [DOI: 10.1021/jm051197e](https://doi.org/10.1021/jm051197e) [PubMed](https://pubmed.ncbi.nlm.nih.gov/16722650/)\n",
        "<br></br>\n",
        "Storn R, Price K. Differential Evolution – A Simple and Efficient Heuristic for Global Optimization over Continuous Spaces. J Glob Optim. 1997; 11: 341–359. [DOI: 10.1023/A:100820282132](https://doi.org/10.1023/A:100820282132)\n",
        "<br></br>\n",
        "Tikhonov, A. N. Solution of Incorrectly Formulated Problems and the Regularization Method. Doklady Akademii Nauk SSSR 1963, 151, 1035–1038. [Google Scholar](https://scholar.google.com/scholar?q=A.+N.+Tikhonov,+Solution+of+incorrectly+formulated+problems+and+the+regularization+method)\n",
        "<br></br>\n",
        "Walsh I, Fishman D, Garcia-Gasulla D, Titma T, Pollastri G; ELIXIR Machine Learning Focus Group; Harrow J, Psomopoulos FE, Tosatto SCE. DOME: recommendations for supervised machine learning validation in biology. Nat Methods. 2021; 18(10): 1122-1127. [DOI: 10.1038/s41592-021-01205-4](https://doi.org/10.1038/s41592-021-01205-4) [PubMed](https://pubmed.ncbi.nlm.nih.gov/34316068/)\n",
        "<br></br>\n",
        "\n",
        "It follows the complete Python code."
      ],
      "metadata": {
        "id": "nOwl-hfFopE9"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 963
        },
        "id": "Jf0RpZqGoL2e",
        "outputId": "f5df59ac-030e-4e30-d458-c4449922ec14"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Downloading the file bind_Ki.csv and splitting it into training and test sets...done!\n",
            "\n",
            "File bind_Ki_training_set.csv has 68 instances.\n",
            "File bind_Ki_test_set.csv has 29 instances.\n",
            "\n",
            "Downloading the file cdk2_Ki_mvd.csv to add SAnDReS-generated data...done!\n",
            "\n",
            "Number of instances written to file cdk2_Ki_mvd_binding_training_set.csv : 68\n",
            "\n",
            "Number of instances written to file cdk2_Ki_mvd_binding_test_set.csv : 29\n",
            "\n",
            "Reading and preprocessing file: cdk2_Ki_mvd_binding_training_set.csv...done!\n",
            "\n",
            "Reading and preprocessing file: cdk2_Ki_mvd_binding_test_set.csv...done!\n",
            "\n",
            "Generating regression model with Ridge...done!\n",
            "\n",
            "Writing metrics to file: regression_metrics.csv...done!\n",
            "\n",
            "Saving scatter plot to file: test_set_scatter_plot.pdf..."
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "done!\n",
            "\n",
            "Parameter vector \n",
            "Intercept:  6.3448\n",
            "Coefficients:  [ 0.25355317 -0.86036592  0.09759926  0.93242623  0.47229071]\n"
          ]
        }
      ],
      "source": [
        "#!/usr/bin/env python3\n",
        "#\n",
        "################################################################################\n",
        "# Dr. Walter F. de Azevedo, Jr.                                                #\n",
        "# [Scopus](https://www.scopus.com/authid/detail.uri?authorId=7006435557)       #\n",
        "# [GitHub](https://github.com/azevedolab)                                      #\n",
        "# July 20, 2024                                                                #\n",
        "################################################################################\n",
        "#\n",
        "################################################################################\n",
        "# Import section                                                               #\n",
        "################################################################################\n",
        "import sys\n",
        "import csv\n",
        "from urllib.request import urlretrieve\n",
        "import pandas as pd\n",
        "from sklearn import preprocessing\n",
        "from sklearn.linear_model import Ridge\n",
        "\n",
        "################################################################################\n",
        "# Define merge() function                                                      #\n",
        "################################################################################\n",
        "def merge(san_in,mvd_in):\n",
        "    \"\"\"Function to merge a SAnDReS-generated file with a MVD-generated file.\"\"\"\n",
        "\n",
        "    # Import section\n",
        "    import csv\n",
        "    import sys\n",
        "\n",
        "    # Define mvd_out string\n",
        "    if \"training\" in san_in:\n",
        "        mvd_out = mvd_in.replace(\".csv\",\"_binding_training_set.csv\")\n",
        "    elif \"test\" in san_in:\n",
        "        mvd_out = mvd_in.replace(\".csv\",\"_binding_test_set.csv\")\n",
        "    else:\n",
        "        mvd_out = mvd_in.replace(\".csv\",\"_binding.csv\")\n",
        "\n",
        "    # Define columns of the SAnDReS CSV file\n",
        "    ref_col_san1 = 9\n",
        "    ref_col_san2 = 11\n",
        "    ref_col_san3 = 13\n",
        "    ref_col_san4 = 16\n",
        "    ref_col_san5 = 17\n",
        "    ref_col_san6 = 18\n",
        "    ref_col_san7 = 24\n",
        "\n",
        "    # Try to open san_in\n",
        "    try:\n",
        "        fo_san = open(san_in,\"r\")\n",
        "        csv_san = csv.reader(fo_san)\n",
        "    except IOError:\n",
        "        msg_out = \"\\nIOError! I can't find file \"+san_in\n",
        "        sys.exit(msg_out)\n",
        "\n",
        "    # Looping through csv_san\n",
        "    for line1 in csv_san:\n",
        "        header1 = str(line1[:ref_col_san1])+\",\"\n",
        "        header1 += str(line1[ref_col_san2:ref_col_san3])+\",\"\n",
        "        header1 += str(line1[ref_col_san4:ref_col_san5])+\",\"\n",
        "        header1 += str(line1[ref_col_san6:ref_col_san7])\n",
        "        header1 = header1.replace(\"[\",\"\").replace(\"]\",\"\").replace(\"'\",\"\").\\\n",
        "                    replace(\" \",\"\").replace(\"AverageQ\",\"Average Q\")\n",
        "\n",
        "        break\n",
        "\n",
        "    # Try to open mvd_in\n",
        "    try:\n",
        "        fo_mvd = open(mvd_in,\"r\")\n",
        "        csv_mvd = csv.reader(fo_mvd)\n",
        "    except IOError:\n",
        "        msg_out = \"\\nIOError! I can't find file \"+mvd_in\n",
        "        sys.exit(msg_out)\n",
        "\n",
        "    # Looping through csv_mvd\n",
        "    for line2 in csv_mvd:\n",
        "        i = 0\n",
        "        for aux in line2:\n",
        "            if aux.strip() == \"SMILES\":\n",
        "                i_SMILES = i\n",
        "            elif aux.strip() == \"Complex\":\n",
        "                i_Complex = i\n",
        "            elif aux.strip() == \"Filename\":\n",
        "                i_Filename = i\n",
        "            elif aux.strip() == \"Ligand\":\n",
        "                i_Ligand = i\n",
        "            elif aux.strip() == \"Path\":\n",
        "                i_Path = i\n",
        "            elif aux.strip() == \"RMSD\":\n",
        "                i_RMSD = i\n",
        "            elif aux.strip() == \"SimilarityScore\":\n",
        "                i_S = i\n",
        "\n",
        "            i += 1\n",
        "\n",
        "        # Clean header2\n",
        "        # Warning!\n",
        "        # This code keeps the labels used in MVD except for\n",
        "        # \"E-Intra (tors, ligand atoms)\".\n",
        "        # We replaced it for \"E-Intra(tors-ligand atoms)\".\n",
        "        header2 = str(line2[i_SMILES+1:i_Complex])+\",\"\n",
        "        header2 += str(line2[i_Complex+1:i_Filename])+\",\"\n",
        "        header2 += str(line2[i_Filename+1:i_Ligand])+\",\"\n",
        "        header2 += str(line2[i_Ligand+1:i_Path])+\",\"\n",
        "        header2 += str(line2[i_Path+1:i_RMSD])+\",\"\n",
        "        header2 += str(line2[i_RMSD+1:i_S])+\",\"\n",
        "        header2 += str(line2[i_S+1:])\n",
        "        header2 = header2.replace(\"[\",\"\").replace(\" \",\"\").\\\n",
        "        replace(\"]\",\"\").replace(\"'\",\"\").\\\n",
        "        replace(\"Cofactor(VdW)\",\"Cofactor (VdW)\").\\\n",
        "        replace(\"Cofactor(elec)\",\"Cofactor (elec)\").\\\n",
        "        replace(\"Cofactor(hbond)\",\"Cofactor (hbond)\").\\\n",
        "        replace(\"E-Inter(cofactor-ligand)\",\"E-Inter (cofactor - ligand)\").\\\n",
        "        replace(\"E-Inter(protein-ligand)\",\"E-Inter (protein - ligand)\").\\\n",
        "        replace(\"E-Inter(water-ligand)\",\"E-Inter (water - ligand)\").\\\n",
        "        replace(\"E-Intertotal\",\"E-Inter total\").\\\n",
        "        replace(\"E-Intra(clash)\",\"E-Intra (clash)\").\\\n",
        "        replace(\"E-Intra(elec)\",\"E-Intra (elec)\").\\\n",
        "        replace(\"E-Intra(hbond)\",\"E-Intra (hbond)\").\\\n",
        "        replace(\"E-Intra(sp2-sp2)\",\"E-Intra (sp2-sp2)\").\\\n",
        "        replace(\"E-Intra(steric)\",\"E-Intra (steric)\").\\\n",
        "        replace(\"E-Intra(tors)\",\"E-Intra (tors)\").\\\n",
        "        replace(\"E-Intra(tors,ligandatoms)\",\"E-Intra (tors-ligand atoms)\").\\\n",
        "        replace(\"E-Intra(vdw)\",\"E-Intra (vdw)\").\\\n",
        "        replace(\"E-SoftConstraintPenalty\",\"E-Soft Constraint Penalty\").\\\n",
        "        replace(\"VdW(LJ12-6)\",\"VdW (LJ12-6)\")\n",
        "\n",
        "        break\n",
        "\n",
        "    # Close fo_mvd to re-open it into the next loop\n",
        "    fo_mvd.close()\n",
        "\n",
        "    # New header\n",
        "    data_out = header1+\",\"+header2+\"\\n\"\n",
        "\n",
        "    # Looping through csv_san\n",
        "    count_instances = 0\n",
        "    for line1 in csv_san:\n",
        "        line_out1 = str(line1[:ref_col_san1])+\",\"\n",
        "        line_out1 += str(line1[ref_col_san2:ref_col_san3])+\",\"\n",
        "        line_out1 += str(line1[ref_col_san4:ref_col_san5])+\",\"\n",
        "        line_out1 += str(line1[ref_col_san6:ref_col_san7])\n",
        "        line_out1 = line_out1.replace(\"[\",\"\").replace(\"]\",\"\").\\\n",
        "                                        replace(\"'\",\"\").replace(\" \",\"\")\n",
        "\n",
        "        # Open mvd_in\n",
        "        fo_mvd = open(mvd_in,\"r\")\n",
        "        csv_mvd = csv.reader(fo_mvd)\n",
        "\n",
        "        count_instances += 1\n",
        "\n",
        "        # Looping through csv_mvd\n",
        "        for line2 in csv_mvd:\n",
        "            if line1[2].strip() in str(line2):\n",
        "\n",
        "                # Clean line_out2\n",
        "                line_out2 = str(line2[i_SMILES+1:i_Complex])+\",\"\n",
        "                line_out2 += str(line2[i_Complex+1:i_Filename])+\",\"\n",
        "                line_out2 += str(line2[i_Filename+1:i_Ligand])+\",\"\n",
        "                line_out2 += str(line2[i_Ligand+1:i_Path])+\",\"\n",
        "                line_out2 += str(line2[i_Path+1:i_RMSD])+\",\"\n",
        "                line_out2 += str(line2[i_RMSD+1:i_S])+\",\"\n",
        "                line_out2 += str(line2[i_S+1:])\n",
        "                line_out2 = line_out2.\\\n",
        "                 replace(\"[\",\"\").replace(\"]\",\"\").replace(\"'\",\"\").replace(\" \",\"\")\n",
        "                data_out += line_out1+\",\"+line_out2+\"\\n\"\n",
        "                fo_mvd.close()\n",
        "                break\n",
        "\n",
        "    # Close fo_san\n",
        "    fo_san.close()\n",
        "\n",
        "    # Open a new file and write data_out\n",
        "    fo_new = open(mvd_out,\"w\")\n",
        "    fo_new.write(data_out)\n",
        "\n",
        "    # Close fo_new\n",
        "    fo_new.close()\n",
        "\n",
        "    # Show message\n",
        "    msg_out = \"\\nNumber of instances written to file \"+mvd_out+\" : \"\n",
        "    msg_out += str(count_instances)\n",
        "    print(msg_out)\n",
        "\n",
        "\n",
        "################################################################################\n",
        "# Define cross_validation() function                                           #\n",
        "################################################################################\n",
        "# Function to set up k-fold class. Kfold class to build a n fold\n",
        "# cross-validation loop and test the generalization ability of regression. With\n",
        "# cross-validation, we generally obtain a more conservative estimate(that is,\n",
        "# the error is larger). The cross-validation estimate is a better estimate of\n",
        "# how well we could generalize to predict on unseen data.\n",
        "#\n",
        "################################################################################\n",
        "# Reference                                                                    #\n",
        "################################################################################\n",
        "# Coelho LP, Richert W. (2015) Building Machine Learning Systems with\n",
        "# Python. 2nd ed. Packt Publishing Ltd. Birmingham UK. 301 pp. See page 162\n",
        "# (Cross-validation for regression)\n",
        "def cross_validation(model,X,y,n_splits,random_state,verbose):\n",
        "\n",
        "    # Import section\n",
        "    from sklearn.model_selection import KFold, cross_val_score\n",
        "    from warnings import simplefilter\n",
        "    import numpy as np\n",
        "\n",
        "    # Set up k-fold class\n",
        "    kf = KFold(n_splits=n_splits,shuffle=True, random_state=random_state)\n",
        "\n",
        "    # Ignore all future warnings\n",
        "    simplefilter(action='ignore', category=DeprecationWarning)\n",
        "\n",
        "    # Looping through kf.split()\n",
        "    for train,test in kf.split(X):\n",
        "\n",
        "        # Generate regression model\n",
        "        model.fit(X[train],y[train])\n",
        "\n",
        "    # Show Walsh metrics if requestes\n",
        "    if verbose:\n",
        "        # Show average coefficient of determination using n-fold crossvalidation\n",
        "        scores = cross_val_score(model,X,y,cv=kf)\n",
        "        msg_out = \"Average coefficient of determination using n-fold \"\n",
        "        msg_out += \"cross-validation\"\n",
        "        print(\"\\n\"+msg_out+\":\",np.mean(scores))\n",
        "\n",
        "    # Return model\n",
        "    return model\n",
        "\n",
        "################################################################################\n",
        "# Define Walsh_and_de_Azevedo_regression_metrics() function                    #\n",
        "################################################################################\n",
        "def Walsh_and_de_Azevedo_regression_metrics(y,y_pred):\n",
        "    \"\"\"Function to calculate regression metrics as recommended by\n",
        "    [Walsh et 2021](https://pubmed.ncbi.nlm.nih.gov/34316068/)\n",
        "    and\n",
        "    [de Azevedo Jr et al., 2024](https://pubmed.ncbi.nlm.nih.gov/38900052/))\n",
        "\n",
        "    Parameters:\n",
        "    y: array with experimental data (dimensions: (n,) )\n",
        "    y_pred: array with predicted values (dimensions: (n,) )\n",
        "\n",
        "    where n is the number of instances\n",
        "    \"\"\"\n",
        "\n",
        "    # Import section for this function\n",
        "    from sklearn.metrics import median_absolute_error\n",
        "    from scipy import stats\n",
        "    import numpy as np\n",
        "\n",
        "    # Determine metrics\n",
        "    n = len(y)\n",
        "    y_bar = y.mean()\n",
        "    rss = np.sum( np.square(y_pred - y) )\n",
        "    rmse =  np.sqrt( (np.sum( (y - y_pred)**2 ))/n )\n",
        "    ss_res = np.sum( (y - y_pred)**2 )\n",
        "    ss_tot = np.sum( (y - y_bar)**2 )\n",
        "    R2 = 1 - ss_res/ss_tot\n",
        "    mae = median_absolute_error(y,y_pred)\n",
        "    r_pearson,p_pearson = stats.pearsonr(y,y_pred)\n",
        "    rho,p_spearman = stats.spearmanr(y,y_pred)\n",
        "    core_dome = rmse**2 + mae**2 + (R2 -1)**2\n",
        "    dome =    np.sqrt( core_dome )\n",
        "    edomer2 = np.sqrt( core_dome + (r_pearson**2 - 1)**2 )\n",
        "    edomerho =np.sqrt( core_dome + (rho**2 - 1)**2 )\n",
        "    edome =   np.sqrt( core_dome + (r_pearson**2 - 1)**2 + (rho**2 - 1)**2 )\n",
        "\n",
        "    # Return metrics\n",
        "    return r_pearson,p_pearson,rho,p_spearman,rss,rmse,mae,R2,dome,edomer2,\\\n",
        "    edomerho,edome\n",
        "\n",
        "################################################################################\n",
        "# Define write_Walsh_and_de_Azevedo_regression_metrics() function              #\n",
        "################################################################################\n",
        "def write_Walsh_and_de_Azevedo_regression_metrics(y_train,y_train_pred,y_test,\n",
        "                                                        y_test_pred,csv_out):\n",
        "\n",
        "    # Set up lists\n",
        "    y_list = [y_train,y_test]\n",
        "    y_pred_list = [y_train_pred,y_test_pred]\n",
        "    data_list = [\"Training Set\",\"Test Set\"]\n",
        "\n",
        "    # Set up empty string\n",
        "    data_out = \"Data,n,r,p-value(r),r2,rho,p-value(rho),RSS,RMSE,MAE,R2,DOME,\"\n",
        "    data_out += \"EDOMEr2,EDOMErho,EDOME\\n\"\n",
        "\n",
        "    # Looping through data\n",
        "    for count,y in enumerate(y_list):\n",
        "\n",
        "        # Call Walsh_and_de_Azevedo_regression_metrics() function\n",
        "        r_pearson,p_pearson,rho,p_spearman,rss,rmse,mae,R2,dome,edomer2,\\\n",
        "        edomerho,edome = \\\n",
        "        Walsh_and_de_Azevedo_regression_metrics(y_list[count],\n",
        "                                                            y_pred_list[count])\n",
        "\n",
        "        # Set up output line\n",
        "        line_out = data_list[count]+\",\"+str(len(y))+\",\"\n",
        "        line_out+= \"{:.4f}\".format(r_pearson)+\",\"+\"{:.4e}\".format(p_pearson)+\",\"\n",
        "        line_out += \"{:.4f}\".format(r_pearson**2)+\",\"+\"{:.4f}\".format(rho)+\",\"\n",
        "        line_out += \"{:.4e}\".format(p_spearman)+\",\"+\"{:.4e}\".format(rss)+\",\"\n",
        "        line_out += \"{:.4f}\".format(rmse)+\",\"+\"{:.4f}\".format(mae)+\",\"\n",
        "        line_out += \"{:.4f}\".format(R2)+\",\"+\"{:.4f}\".format(dome)+\",\"\n",
        "        line_out += \"{:.4f}\".format(edomer2)+\",\"+\"{:.4f}\".format(edomerho)+\",\"\n",
        "        line_out += \"{:.4f}\".format(edome)\n",
        "\n",
        "        # Update data_out\n",
        "        data_out += line_out+\"\\n\"\n",
        "\n",
        "    # Open a new file and write data_out\n",
        "    fo_out = open(csv_out,\"w\")\n",
        "    fo_out.write(data_out)\n",
        "    fo_out.close()\n",
        "\n",
        "    # Return rmse\n",
        "    return rmse\n",
        "\n",
        "################################################################################\n",
        "# Define scatter_plot() function                                               #\n",
        "################################################################################\n",
        "def scatter_plot(y,y_pred,data_in,color_in,color_reg,plt_out,x_l,y_l,title,\n",
        "                 xlim,ylim,dpi):\n",
        "    \"\"\"Function to generate a basic scatter plot\"\"\"\n",
        "\n",
        "    # Import section\n",
        "    import numpy as np\n",
        "    import matplotlib.pyplot as plt\n",
        "\n",
        "    # Create basic scatterplot\n",
        "    plt.plot(y, y_pred,data_in,color=color_in)\n",
        "\n",
        "    # Obtain m (slope) and b(intercept) of Ridge regression line\n",
        "    m, b = np.polyfit(y,y_pred, 1)\n",
        "\n",
        "    y_in = np.linspace(xlim[0], xlim[1], 100)\n",
        "\n",
        "    # Use color_reg as color for regression line\n",
        "    plt.plot(y_in, m*y_in+b, color=color_reg)\n",
        "    plt.xlabel(x_l,fontsize = 14)\n",
        "    plt.ylabel(y_l,fontsize = 14)\n",
        "    plt.title(title,fontsize = 12)\n",
        "    plt.xlim( xlim )\n",
        "    plt.ylim( ylim )\n",
        "    plt.grid()\n",
        "    plt.savefig(plt_out,dpi=dpi)\n",
        "    plt.show()\n",
        "\n",
        "################################################################################\n",
        "# main function                                                                #\n",
        "################################################################################\n",
        "def main():\n",
        "\n",
        "    ############################################################################\n",
        "    # Split dataset\n",
        "    ############################################################################\n",
        "    sandres_bind_in = \"bind_Ki.csv\"              # Update here for a new dataset\n",
        "    url4sandres_bind_in = \\\n",
        "              \"https://bit.ly/cdk2_Ki_sandres\"   # Update here for a new dataset\n",
        "    msg_out = \"\\nDownloading the file \"+sandres_bind_in+\" and splitting it \"\n",
        "    msg_out += \"into training and test sets\"\n",
        "    print(msg_out,end=\"...\")\n",
        "    urlretrieve(url4sandres_bind_in, sandres_bind_in)\n",
        "\n",
        "    # Define PDB access codes for the test set\n",
        "    test_set = [\"EL4C\",\"38QX\",\"ARNY\",\"EB8B\",\"MHNA\",\"0UTY\",\"5GFN\",\"M50X\",\"BN07\",\n",
        "    \"7WSJ\",\"RBRI\",\"38R7\",\"XBUL\",\"1XN5\",\"SKL3\",\"ICRX\",\"VWKX\",\"INK5\",\"45B2\",\n",
        "    \"19M2\",\"3SM7\",\"06QM\",\"5ZEJ\",\"GKUV\",\"8AT0\",\"44WP\",\"8YJR\",\"RUXV\",\n",
        "                \"7PXQ\"]                          # Update here for a new dataset\n",
        "\n",
        "    # Try to open a csv file\n",
        "    try:\n",
        "        fo_bind = open(sandres_bind_in,\"r\")\n",
        "        csv_bind = csv.reader(fo_bind)\n",
        "    except IOError:\n",
        "        msg_out = \"\\nIOError! I can't find file \"+sandres_bind_in+\"!\"\n",
        "        sys.exit(msg_out)\n",
        "\n",
        "    # Get header\n",
        "    for line in csv_bind:\n",
        "        training_out = \"\"\n",
        "\n",
        "        # Looping through column labels\n",
        "        for line1 in line:\n",
        "            training_out += line1.strip()+\",\"\n",
        "\n",
        "        training_out = training_out[:len(training_out)-1]+\"\\n\"\n",
        "        test_out = training_out\n",
        "        break\n",
        "\n",
        "    # Assign zero to count_train\n",
        "    count_train = 0\n",
        "\n",
        "    # Looping through csv_bind\n",
        "    for line in csv_bind:\n",
        "        if line[0].strip() in test_set:\n",
        "            test_out += str(line).replace(\"[\",\"\").replace(\"]\",\"\").\\\n",
        "                        replace(\"'\",\"\").replace(\" \",\"\")+\"\\n\"\n",
        "        else:\n",
        "            training_out += str(line).replace(\"[\",\"\").replace(\"]\",\"\").\\\n",
        "                        replace(\"'\",\"\").replace(\" \",\"\")+\"\\n\"\n",
        "            count_train += 1\n",
        "\n",
        "    # Open new files\n",
        "    training_set_file = sandres_bind_in.replace(\".csv\",\"_training_set.csv\")\n",
        "    test_set_file = sandres_bind_in.replace(\".csv\",\"_test_set.csv\")\n",
        "    fo_training = open(training_set_file,\"w\")\n",
        "    fo_test = open(test_set_file,\"w\")\n",
        "\n",
        "    # Write data\n",
        "    fo_training.write(training_out)\n",
        "    fo_test.write(test_out)\n",
        "\n",
        "    # Close files\n",
        "    fo_bind.close()\n",
        "    fo_training.close()\n",
        "    fo_test.close()\n",
        "\n",
        "    # Show message\n",
        "    print(\"done!\")\n",
        "    msg_out = \"\\nFile \"+training_set_file+\" has \"+str(count_train)+\" instances.\"\n",
        "    msg_out += \"\\nFile \"+test_set_file+\" has \"+str(len(test_set))+\" instances.\"\n",
        "    print(msg_out)\n",
        "\n",
        "    ############################################################################\n",
        "    # Merge dataset\n",
        "    ############################################################################\n",
        "    # Docking results generated with MVD\n",
        "    mvd_in = \"cdk2_Ki_mvd.csv\"                   # Update here for a new dataset\n",
        "    url_mvd_in =  \"https://bit.ly/cdk2_Ki_mvd\"   # Update here for a new dataset\n",
        "    msg_out = \"\\nDownloading the file \"+mvd_in+\" to add SAnDReS-generated data\"\n",
        "    print(msg_out,end=\"...\")\n",
        "    urlretrieve(url_mvd_in, mvd_in)\n",
        "    print(\"done!\")\n",
        "\n",
        "    # Define SAnDReS-generated files for the training and test sets\n",
        "    san_training_in = \"bind_Ki_training_set.csv\"  # File generated using SAnDReS\n",
        "    san_test_in = \"bind_Ki_test_set.csv\"          # File generated using SAnDReS\n",
        "\n",
        "    # Call merge() function for the training set\n",
        "    merge(san_training_in,mvd_in)\n",
        "\n",
        "    # Call merge() function for the test set\n",
        "    merge(san_test_in,mvd_in)\n",
        "\n",
        "    ############################################################################\n",
        "    # Training set\n",
        "    ############################################################################\n",
        "    training_set_file_in = \\\n",
        "    \"cdk2_Ki_mvd_binding_training_set.csv\"       # Update here for a new dataset\n",
        "    print(\"\\nReading and preprocessing file: \"+training_set_file_in,end=\"...\")\n",
        "    feature_list = [\"Average Q\",\"C\",\"Csp2\",\"HeavyAtoms\",\n",
        "                    \"Steric\"]                    # Update here for a new dataset\n",
        "    training_set_data = pd.read_csv(training_set_file_in,delimiter=\",\")\n",
        "    y_train = training_set_data.iloc[:,8]        # Update here for a new dataset\n",
        "    print(\"done!\")\n",
        "\n",
        "    ############################################################################\n",
        "    # Test set\n",
        "    ###########################################################################\n",
        "    test_set_file_in = \\\n",
        "    \"cdk2_Ki_mvd_binding_test_set.csv\"           # Update here for a new dataset\n",
        "    print(\"\\nReading and preprocessing file: \"+test_set_file_in,end=\"...\")\n",
        "    test_set_data = pd.read_csv(test_set_file_in,delimiter=\",\")\n",
        "    y_test = test_set_data.iloc[:,8]             # Update here for a new dataset\n",
        "    print(\"done!\")\n",
        "\n",
        "    ############################################################################\n",
        "    # Define additional inputs\n",
        "    ############################################################################\n",
        "    plt_scatter_X_label_str,plt_scatter_y_label_str = \"pK$_i$ (Experimental)\",\\\n",
        "                        \"pK$_i$ (Predicted)\"            # Define labels for axes\n",
        "    plt_dpi = 1500                                      # Plot dpi\n",
        "\n",
        "    ############################################################################\n",
        "    # Build a regression model with Ridge\n",
        "    ############################################################################\n",
        "    msg_out = \"\\nGenerating regression model with Ridge\"\n",
        "    print(msg_out,end=\"...\")\n",
        "\n",
        "    # For training set\n",
        "    X_train = training_set_data[feature_list]\n",
        "    scaler_train = preprocessing.StandardScaler().fit(X_train)\n",
        "    X_train = scaler_train.transform(X_train)\n",
        "\n",
        "    # For test set\n",
        "    X_test = test_set_data[feature_list]\n",
        "    scaler_test = preprocessing.StandardScaler().fit(X_test)\n",
        "    X_test = scaler_test.transform(X_test)\n",
        "\n",
        "    # Instantiate an object of Ridge() class\n",
        "    lin_reg = Ridge(alpha = 0.04,\n",
        "                    solver = \"cholesky\",\n",
        "                    random_state = 46).fit(X_train, y_train)\n",
        "\n",
        "    # Call cross_validation() function\n",
        "    lin_reg = cross_validation(lin_reg,X_train,y_train,5,46,False)\n",
        "    y_train_pred_reg = lin_reg.predict(X_train)\n",
        "    y_test_pred_reg = lin_reg.predict(X_test)\n",
        "    print(\"done!\")\n",
        "\n",
        "    # Call write_Walsh_and_de_Azevedo_regression_metrics() function\n",
        "    print(\"\\nWriting metrics to file: regression_metrics.csv\",end=\"...\")\n",
        "    csv_out = \"regression_metrics.csv\"\n",
        "    rmse = write_Walsh_and_de_Azevedo_regression_metrics(y_train,\n",
        "                            y_train_pred_reg,y_test,y_test_pred_reg,csv_out)\n",
        "    print(\"done!\")\n",
        "\n",
        "    # Call scatter_plot() function\n",
        "    print(\"\\nSaving scatter plot to file: test_set_scatter_plot.pdf\",end=\"...\")\n",
        "    plt_scatter_title_str = \"CDK2 K$_i$ (Test Set)\"\n",
        "                                                 # Update here for a new dataset\n",
        "    plt_scatter_title_str += \" (RMSE: {:.4f}\".format(rmse)+\")\"\n",
        "    plot_out = \"test_set_scatter_plot.pdf\"\n",
        "    xlim = (2.0, 12.0)                           # Update here for a new dataset\n",
        "    ylim = (2.0, 12.0)                           # Update here for a new dataset\n",
        "    scatter_plot(y_test,y_test_pred_reg,\".\",\"blue\",\"black\",plot_out,\n",
        "    plt_scatter_X_label_str,plt_scatter_y_label_str,plt_scatter_title_str,xlim,\n",
        "             ylim,plt_dpi)\n",
        "    print(\"done!\")\n",
        "\n",
        "    # Show parameter vector\n",
        "    print(\"\\nParameter vector \")\n",
        "    print(\"Intercept:  {:.4f}\".format(lin_reg.intercept_))\n",
        "    print(\"Coefficients: \",lin_reg.coef_)\n",
        "\n",
        "# Call main() function\n",
        "main()\n",
        "################################################################################"
      ]
    }
  ]
}