LINCS_MOA_Prostate_LinearClassifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LINCS MOA classification for Prostate tissue using Logistic regression(linear classifier)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.preprocessing  import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.metrics import confusion_matrix,classification_report,accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_prostate=pd.read_hdf(\"/Users/Rashid/Desktop/Rashid/Career/PhD/Research/projects/GCN/data/GSE92742_fully_restricted_prostate.hdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_prostate=file_prostate.reset_index(level=[0,1,2,3,4,5,6]) #change from multi index to single index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "prostate_y=df_prostate[\"moa\"].values #change moa column to numpy array\n",
    "df_prostate= df_prostate.drop(columns=[\"pert_id\",\"pert_name\",\"cell_id\",\"primary_site\",\"subtype\",\"moa\",\"Fold\"])\n",
    "prostate_X=df_prostate.values #get the matrix of feature values for 978 genes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels,uniques=pd.factorize(prostate_y) #labels are the encodings\n",
    "prostate_y=labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc=StandardScaler()\n",
    "prostate_X=sc.fit_transform(prostate_X) #normalize feature data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#SPLIT DATA\n",
    "X_train,X_test,y_train,y_test=train_test_split(prostate_X,prostate_y,test_size=0.2,random_state=42)#split into train and test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/envs/scikitLearnTutorial/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:561: ConvergenceWarning: Maximum number of iteration reached before convergence. Consider increasing max_iter to improve the fit.\n",
      "  ConvergenceWarning)\n"
     ]
    }
   ],
   "source": [
    "lc = SGDClassifier()\n",
    "lc.fit(X_train,y_train)\n",
    "pred_lc=lc.predict(X_test)  #3-4 min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  31    1   15   10    9   20   28  125    0]\n",
      " [   6  158    3    2    2   13   13   25    0]\n",
      " [  22    1  126   29   16   37   37  157    3]\n",
      " [  10    0   19   21   10   14   28  116    1]\n",
      " [  12    0   10   12   28   16   24  102    0]\n",
      " [  16    0   11   11   20  673   39  152    5]\n",
      " [  16    1   17   15   13   20  525  206   89]\n",
      " [  83    2   61   57   85   87  181 1178   12]\n",
      " [   4    0    3    2    0    3  115   40   59]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.15      0.13      0.14       239\n",
      "           1       0.97      0.71      0.82       222\n",
      "           2       0.48      0.29      0.36       428\n",
      "           3       0.13      0.10      0.11       219\n",
      "           4       0.15      0.14      0.14       204\n",
      "           5       0.76      0.73      0.74       927\n",
      "           6       0.53      0.58      0.55       902\n",
      "           7       0.56      0.67      0.61      1746\n",
      "           8       0.35      0.26      0.30       226\n",
      "\n",
      "    accuracy                           0.55      5113\n",
      "   macro avg       0.45      0.40      0.42      5113\n",
      "weighted avg       0.54      0.55      0.54      5113\n",
      "\n",
      "0.5474281243888128\n"
     ]
    }
   ],
   "source": [
    "#METRICS\n",
    "print(confusion_matrix(y_test,pred_lc))\n",
    "print(classification_report(y_test,pred_lc))\n",
    "acc_lc=accuracy_score(y_test,pred_lc) #result for linear classification\n",
    "print(acc_lc) #print precision score \n",
    "#results doesn't quite matches in the paper where accuracy is 63.8 ± 0.52, macro F1 is 42.6 ± 1.03. Took 3-4 minutes on macbook pro 2.7 GHz inter core i5 processor, 16 GB 1867 MHz DDR3 Memomry, Intel Iris Graphics 6100 1536 MB Graphics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_benchmark = SGDClassifier(eta0= 0.00031685190815167104, l1_ratio= 0.40558624196055393, tol=1e-05, penalty='l1', random_state= 101, max_iter= 1000, learning_rate= 'invscaling', alpha= 0.0012311722512335377, n_jobs= -1, power_t= 0.1840171707888663, loss= 'log')\n",
    "lc_benchmark.fit(X_train,y_train)\n",
    "pred_lc_benchmark=lc_benchmark.predict(X_test)  #3-4 min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  10    0   17    2    0    8   21  180    1]\n",
      " [   3  167    0    0    0    6    7   39    0]\n",
      " [   5    0  157    4    2   26   25  208    1]\n",
      " [   0    0   29    0    1   11   19  158    1]\n",
      " [   2    1    5    1    8   11   11  165    0]\n",
      " [   3    1    6    1    2  661   24  229    0]\n",
      " [   1    0    2    3    0    8  625  252   11]\n",
      " [   5    1   15    4    5   35   96 1581    4]\n",
      " [   0    0    1    0    0    1  172   39   13]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.34      0.04      0.07       239\n",
      "           1       0.98      0.75      0.85       222\n",
      "           2       0.68      0.37      0.48       428\n",
      "           3       0.00      0.00      0.00       219\n",
      "           4       0.44      0.04      0.07       204\n",
      "           5       0.86      0.71      0.78       927\n",
      "           6       0.62      0.69      0.66       902\n",
      "           7       0.55      0.91      0.69      1746\n",
      "           8       0.42      0.06      0.10       226\n",
      "\n",
      "    accuracy                           0.63      5113\n",
      "   macro avg       0.55      0.40      0.41      5113\n",
      "weighted avg       0.61      0.63      0.58      5113\n",
      "\n",
      "0.6301584197144533\n"
     ]
    }
   ],
   "source": [
    "#METRICS\n",
    "print(confusion_matrix(y_test,pred_lc_benchmark))\n",
    "print(classification_report(y_test,pred_lc_benchmark))\n",
    "acc_lc_benchmark=accuracy_score(y_test,pred_lc_benchmark) #result for linear classification\n",
    "print(acc_lc_benchmark) #print precision score \n",
    "#result matches with actual benchmark test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:scikitLearnTutorial]",
   "language": "python",
   "name": "conda-env-scikitLearnTutorial-py"
  },
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}