DNN_trained_with_nGlyde_test_with_nglyde.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import keras\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.utils import shuffle\n",
    "from sklearn.model_selection import train_test_split\n",
    "from keras.layers import Dense, Bidirectional,Dense, LSTM, Activation, Dropout, Flatten\n",
    "from keras.layers import LeakyReLU\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import matthews_corrcoef\n",
    "from sklearn.metrics import accuracy_score\n",
    "from keras.models import Sequential\n",
    "import tensorflow as tf\n",
    "from keras.regularizers import l2\n",
    "from tensorflow.keras import regularizers\n",
    "from sklearn.metrics import classification_report,roc_curve,auc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = pd.read_excel(\"447_feature_test.xlsx\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NetSurfP2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "664\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "X_test_Net = test.iloc[:,1783:1983]\n",
    "y_test_Net = test[\"Target\"]\n",
    "\n",
    "\n",
    "print(X_test_Net.isnull().sum().sum())\n",
    "X_test_Net.fillna(0,inplace=True)\n",
    "print(X_test_Net.isnull().sum().sum())\n",
    "\n",
    "scaler = MinMaxScaler()\n",
    "\n",
    "\n",
    "X_test_Net = scaler.fit_transform(X_test_Net)\n",
    "\n",
    "\n",
    "X_test_Net = np.array(X_test_Net)\n",
    "y_test_Net = np.array(y_test_Net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gapped Dipeptide Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test_GD = test.iloc[:,1983:2007]\n",
    "y_test_GD = test[\"Target\"]\n",
    "\n",
    "\n",
    "scaler = MinMaxScaler()\n",
    "\n",
    "\n",
    "X_test_GD = scaler.fit_transform(X_test_GD)\n",
    "\n",
    "\n",
    "X_test_GD = np.array(X_test_GD)\n",
    "y_test_GD = np.array(y_test_GD)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PSSM Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1660\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "X_test_PSSM = test.iloc[:,1283:1783]\n",
    "y_test_PSSM = test[\"Target\"]\n",
    "\n",
    "\n",
    "print(X_test_PSSM.isnull().sum().sum())\n",
    "X_test_PSSM.fillna(0,inplace=True)\n",
    "print(X_test_PSSM.isnull().sum().sum())\n",
    "\n",
    "scaler = MinMaxScaler()\n",
    "\n",
    "\n",
    "X_test_PSSM = scaler.fit_transform(X_test_PSSM)\n",
    "\n",
    "\n",
    "X_test_PSSM = np.array(X_test_PSSM)\n",
    "y_test_PSSM = np.array(y_test_PSSM)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Combine Three Features (NetSurfP-2.0, Gapped Dipeptide, PSSM) and Check the size of the matrix, shuffle it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(447, 724) (447,)\n"
     ]
    }
   ],
   "source": [
    "X_test_Net_PSSM_GD = np.hstack((X_test_Net,X_test_PSSM,X_test_GD))\n",
    "\n",
    "y_test_Net_PSSM_GD = y_test_Net\n",
    "\n",
    "\n",
    "X_test, y_test = shuffle(X_test_Net_PSSM_GD, y_test_Net_PSSM_GD, random_state=7)\n",
    "X_test = np.array(X_test)\n",
    "y_test = np.array(y_test)\n",
    "\n",
    "\n",
    "print(X_test.shape,y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load the model and see the performance matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matthews Correlation :  0.5310682030023739\n",
      "Confusion Matrix : \n",
      " [[227  53]\n",
      " [ 46 121]]\n",
      "Accuracy on test set:    0.7785234899328859\n",
      "0.5310682030023739\n",
      "Sensitivity:    0.7245508982035929 \t Specificity:    0.8107142857142857\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.83      0.81      0.82       280\n",
      "           1       0.70      0.72      0.71       167\n",
      "\n",
      "    accuracy                           0.78       447\n",
      "   macro avg       0.76      0.77      0.77       447\n",
      "weighted avg       0.78      0.78      0.78       447\n",
      "\n",
      "Area Under Curve:    0.7676325919589393\n"
     ]
    }
   ],
   "source": [
    "model = keras.models.load_model(\"3080_NetSurfP2.0_PSSM_GD\"+str(8)+\".h5\")\n",
    "Y_pred = model.predict(X_test)\n",
    "Y_pred = (Y_pred > 0.5)\n",
    "y_pred = [np.argmax(y, axis=None, out=None) for y in Y_pred]\n",
    "y_pred = np.array(y_pred)\n",
    "print(\"Matthews Correlation : \",matthews_corrcoef(y_test, y_pred))\n",
    "print(\"Confusion Matrix : \\n\",confusion_matrix(y_test, y_pred))\n",
    "print(\"Accuracy on test set:   \",accuracy_score(y_test, y_pred))\n",
    "\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "mcc = matthews_corrcoef(y_test, y_pred)\n",
    "print(mcc)\n",
    "\n",
    "TP = cm[1][1]\n",
    "TN = cm[0][0]\n",
    "FP = cm[0][1]\n",
    "FN = cm[1][0]\n",
    "\n",
    "Sensitivity = TP/(TP+FN)\n",
    "\n",
    "Specificity = TN/(TN+FP)\n",
    "\n",
    "print(\"Sensitivity:   \",Sensitivity,\"\\t\",\"Specificity:   \",Specificity)\n",
    "\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n",
    "fpr, tpr, _ = roc_curve(y_test, y_pred)\n",
    "\n",
    "roc_auc_test = auc(fpr,tpr)\n",
    "\n",
    "print(\"Area Under Curve:   \",roc_auc_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}