complete_model_X6_.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "complete model  X6 .ipynb",
      "provenance": [],
      "collapsed_sections": [
        "dC73090pTc3j"
      ],
      "toc_visible": true,
      "authorship_tag": "ABX9TyP8AAqoQfxWDk1atPuD3+nE"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KporO__CRyLW"
      },
      "source": [
        "#####Pre-requisites (Installation)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "whQCUN5ovvfM"
      },
      "source": [
        "!pip install --upgrade pip"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zww-pmnMxOE6"
      },
      "source": [
        "!pip install tensorflow"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "szpEB00txTQM"
      },
      "source": [
        "!pip install tf-nightly"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J-INdnbkxa0j"
      },
      "source": [
        "from __future__ import absolute_import, division, print_function, unicode_literals\n",
        "\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "\n",
        "print(tf.__version__)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pak5MUNE3RDP"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/gdrive/')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ob3cgO2tF8JD"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ujBP8MN3FO_"
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p7es279aueiM"
      },
      "source": [
        "vacand = pd.read_csv('/gdrive/My Drive/joint1c.csv',sep = ',', skipinitialspace=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8O6lxrQfueri"
      },
      "source": [
        "vacand = pd.read_csv ('/gdrive/My Drive/joint1c.csv', sep='\\s*,\\s*', skipinitialspace=True, engine='python')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZipRrLBWy5eL"
      },
      "source": [
        "vacand"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "buAg0YM2zNkS"
      },
      "source": [
        "vacand = vacand.drop('PEPTIDE',axis = 1)\n",
        "vacand"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rixtnLiV2800"
      },
      "source": [
        "target_column = ['CATEGORY'] \n",
        "predictors = list(set(list(vacand.columns))-set(target_column))\n",
        "vacand[predictors] = vacand[predictors]/vacand[predictors].max()\n",
        "vacand.describe()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EvdPjzzcG_r_"
      },
      "source": [
        "X = pd.DataFrame(vacand[predictors].values)\n",
        "Y = pd.DataFrame(vacand[target_column].values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fi4Tkr61HBe7"
      },
      "source": [
        "X.shape, Y.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LEkpF2WIHBmM"
      },
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "\n",
        "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.2, random_state = 20)\n",
        "\n",
        "X_train, X_val, Y_train, Y_val  = train_test_split(X_train, Y_train, test_size=0.25, random_state=20)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GYffS0j-HBs0"
      },
      "source": [
        "from keras.utils import to_categorical\n",
        "\n",
        "Y_train = to_categorical(Y_train)\n",
        "Y_test = to_categorical(Y_test)\n",
        "Y_val = to_categorical(Y_val)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dsyLJzMvJS41"
      },
      "source": [
        "count_classes = Y_test.shape[1]\n",
        "print(count_classes)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UqVx0gaTYu14"
      },
      "source": [
        "count_classes = Y_val.shape[1]\n",
        "print(count_classes)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8tgFde4Cxc_G"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HTeqbqYFxcx4"
      },
      "source": [
        "from sklearn.preprocessing import MinMaxScaler\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JqYxoF-ExctK"
      },
      "source": [
        "scaler = MinMaxScaler()\n",
        "scaler.fit(X_train)\n",
        "\n",
        "X_train = scaler.fit_transform(X_train)\n",
        "X_test = scaler.fit_transform(X_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QRL0sVaLxiSr"
      },
      "source": [
        "X_train.min(), X_train.max()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YLlbUb_SxmvR"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4KBow288TFiC"
      },
      "source": [
        "####Model building & Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2BGEVCkxHBuf"
      },
      "source": [
        "from keras.wrappers.scikit_learn import KerasClassifier\n",
        "from sklearn.model_selection import cross_val_score\n",
        "from keras.models import Sequential \n",
        "from keras.layers import Dense,Dropout\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "leDTmA0hHTE_"
      },
      "source": [
        "from tensorflow.keras import layers\n",
        "import tensorflow as tf\n",
        "\n",
        "#model = Sequential()\n",
        "\n",
        "model = tf.keras.Sequential()\n",
        "\n",
        "# Adds a densely-connected layer with 10 units to the model:\n",
        "model.add(layers.Dense(10, activation='relu'))\n",
        "model.add(layers.Dropout(0.5))\n",
        "\n",
        "# Add another:\n",
        "model.add(layers.Dense(3, activation='relu'))\n",
        "model.add(layers.Dropout(0.5))\n",
        "\n",
        "# Add a layer with 2 output units:\n",
        "model.add(layers.Dense(2,  activation='sigmoid'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JkD2kIwNHTLz"
      },
      "source": [
        "model.compile(optimizer=tf.keras.optimizers.Adam(),\n",
        "              loss='binary_crossentropy',\n",
        "              metrics=['BinaryAccuracy'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aO7-JxN1Lwrq"
      },
      "source": [
        "Accuracy, Loss & other results\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o8fkv6bDHTXm"
      },
      "source": [
        "history1 = model.fit(X_train, Y_train, epochs=80,validation_data=(X_val, Y_val),verbose = 0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YP0jZnib94Xd"
      },
      "source": [
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hrllvISsHTKO"
      },
      "source": [
        "#pred_train= model.predict(X_train)\n",
        "#scores = model.evaluate(X_train, Y_train, verbose=0)\n",
        "#print('Accuracy on training data: {}% \\n Error on training data: {}'.format(scores[1], 1 - scores[1])) \n",
        "\n",
        "pred_train= model.predict(X_val)\n",
        "scores = model.evaluate(X_val, Y_val, verbose=0)\n",
        "print('Accuracy on validation data: {}% \\n Error on validation data: {}'.format(scores[1], 1 - scores[1])) \n",
        " \n",
        "pred_test= model.predict(X_test)\n",
        "scores2 = model.evaluate(X_test, Y_test, verbose=0)\n",
        "print('\\n Accuracy on test data: {}% \\n Error on test data: {}'.format(scores2[1], 1 - scores2[1]))\n",
        "\n",
        "print('\\n test loss, test acc:', scores2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eP5RzHrSFhHC"
      },
      "source": [
        "model.metrics_names\n",
        "\n",
        "# list all data in history\n",
        "print(history1.history.keys())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sp7Jk8oUx_-g"
      },
      "source": [
        "losses = pd.DataFrame(history1.history)\n",
        "losses.plot()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zJqcrPWzGeL8"
      },
      "source": [
        "for i in range(0,len(pred_test)):\n",
        "  for j in range(0,len(pred_test[i])):\n",
        "    if(pred_test[i,j]<=0.5):\n",
        "      pred_test[i,j]=0\n",
        "    else:\n",
        "      pred_test[i,j]=1\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V_JDmXgz9P36"
      },
      "source": [
        "from sklearn.metrics import accuracy_score\n",
        "accuracy_score(Y_test, pred_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HLRSzNm14kpF"
      },
      "source": [
        "pred_train.shape, pred_test.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SY_Qy0-30LVK"
      },
      "source": [
        "Y_train.shape,Y_test.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DpmPyQkd0K9R"
      },
      "source": [
        "X_train.shape, X_test.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jDa-_6qa0IwZ"
      },
      "source": [
        "predictions = pd.DataFrame(model.predict(X_test))\n",
        "predictions"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tKMGGAHe9EpT"
      },
      "source": [
        "pred_test"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X8L4yi_v85Pf"
      },
      "source": [
        "from sklearn.metrics import classification_report\n",
        "\n",
        "print(classification_report(Y_test,pred_test))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RRvNfS4n1II0"
      },
      "source": [
        "Y_test_new=[]\n",
        "pred_test_new=[]\n",
        "for i in Y_test:\n",
        "  for j in range(0,len(i)):\n",
        "    if(i[j]==1):\n",
        "      Y_test_new.append(j)\n",
        "for i in pred_test:\n",
        "  for j in range(0,len(i)):\n",
        "    if(i[j]==1):\n",
        "      pred_test_new.append(j)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xpk8dTHT1IBx"
      },
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "import sklearn.metrics as metrics\n",
        "confusion_matrix = metrics.confusion_matrix(Y_test_new,pred_test_new)\n",
        "confusion_matrix"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4SaxNxc4fGBl"
      },
      "source": [
        "#import matplotlib.pyplot as plt \n",
        "!pip install scikit-plot"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L6G6835FfFqN"
      },
      "source": [
        "import scikitplot as skplt\n",
        "skplt.metrics.plot_confusion_matrix(Y_test_new,pred_test_new, normalize=True)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FLB6Xdum5S0L"
      },
      "source": [
        "from sklearn.metrics import roc_curve, auc\n",
        "\n",
        "fpr_nn,tpr_nn, thresholds = roc_curve(Y_test_new, pred_test_new)\n",
        "roc_auc_nn = auc(fpr_nn,tpr_nn)\n",
        "roc_auc_nn\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0cwiK3nA5Syd"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.figure(figsize=(8,8))\n",
        "plt.title('Receiver Operating Characteristic')\n",
        "plt.plot(fpr_nn,tpr_nn, color='red',label = 'AUC = %0.2f' % roc_auc_nn)\n",
        "plt.legend(loc = 'lower right')\n",
        "plt.plot([0, 1], [0, 1],linestyle='--')\n",
        "plt.axis('tight')\n",
        "plt.ylabel('True Positive Rate')\n",
        "plt.xlabel('False Positive Rate')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UXamPP5vLcqV"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bW9tFGf9Lc5c"
      },
      "source": [
        "from sklearn.metrics import average_precision_score, precision_recall_curve\n",
        "\n",
        "average_precision = average_precision_score(Y_test_new,pred_test_new)\n",
        "\n",
        "print('Average precision-recall score: {}'.format(average_precision))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NWSkVG0ELdCi"
      },
      "source": [
        "precision, recall, _ = precision_recall_curve(Y_test_new,pred_test_new)\n",
        "\n",
        "plt.step(recall, precision, color='b', alpha=0.2,\n",
        "         where='post')\n",
        "plt.fill_between(recall, precision, step='post', alpha=0.2,\n",
        "                 color='b')\n",
        "\n",
        "plt.xlabel('Recall')\n",
        "plt.ylabel('Precision')\n",
        "plt.ylim([0.0, 1.05])\n",
        "plt.xlim([0.0, 1.0])\n",
        "plt.title('2-class Precision-Recall curve: AP={0:0.2f}'.format(\n",
        "          average_precision))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3WWW1brrLdBD"
      },
      "source": [
        "!mkdir -p saved_model\n",
        "model.save('saved_mymodel/my_model') "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dfgjAOicOY3q"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}