Prediction-RFC-Diff.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "np.random.seed(42)\n",
    "from sklearn.model_selection import train_test_split as splt\n",
    "from sklearn.ensemble import RandomForestClassifier as rfc\n",
    "from sklearn.model_selection import RepeatedStratifiedKFold as rskf\n",
    "from sklearn.metrics import matthews_corrcoef as mcc\n",
    "from sklearn.metrics import accuracy_score as acc\n",
    "from scipy.sparse import csr_matrix \n",
    "import matplotlib.pyplot as plt\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_coltype(df, headers):\n",
    "    return df\n",
    "    boolval = []\n",
    "    headers = headers + [\"subject_id\", \"ScoreClass\", \"visit\"]\n",
    "    for header in headers:\n",
    "        boolval.append(df.columns.str.startswith(header))\n",
    "    return df[df.columns[np.any(boolval, axis=0)]]\n",
    "def prepare_dataset(X, y, x_ind, y_ind):\n",
    "    X_, y_ = [], []\n",
    "    for i in x_ind:\n",
    "        X_.append(X[i])\n",
    "    for i in y_ind:\n",
    "        y_.append(y[i])\n",
    "    return (X_,y_)\n",
    "def bootstrap_ci(x, B=1000, alpha=0.05, seed=42):\n",
    "    \"\"\"Computes the (1-alpha) Bootstrap confidence interval\n",
    "    from empirical bootstrap distribution of sample mean.\n",
    "\n",
    "    The lower and upper confidence bounds are the (B*alpha/2)-th\n",
    "    and B * (1-alpha/2)-th ordered means, respectively.\n",
    "    For B = 1000 and alpha = 0.05 these are the 25th and 975th\n",
    "    ordered means.\n",
    "    \"\"\"\n",
    "\n",
    "    x_arr = np.ravel(x)\n",
    "\n",
    "    if B < 2:\n",
    "        raise ValueError(\"B must be >= 2\")\n",
    "\n",
    "    if alpha < 0 or alpha > 1:\n",
    "        raise ValueError(\"alpha must be in [0, 1]\")\n",
    "\n",
    "    np.random.seed(seed)\n",
    "\n",
    "    bmean = np.empty(B, dtype=np.float)\n",
    "    for b in range(B):\n",
    "        idx = np.random.random_integers(0, x_arr.shape[0]-1, x_arr.shape[0])\n",
    "        bmean[b] = np.mean(x_arr[idx])\n",
    "\n",
    "    bmean.sort()\n",
    "    lower = int(B * (alpha * 0.5))\n",
    "    upper = int(B * (1 - (alpha * 0.5)))\n",
    "\n",
    "    return (bmean[lower], bmean[upper])\n",
    "\n",
    "def get_data_for_trial_diff(df, headers):\n",
    "    df_specific = prep_coltype(df, headers)\n",
    "    d = {i: df_specific.loc[df_specific.subject_id == i, df_specific.columns] for i in range(df_specific.subject_id.iat[-1]+1)}\n",
    "    d = {dx: d[dx] for dx in d if d[dx].shape[0] != 0}\n",
    "    X = []\n",
    "    y = []\n",
    "    for _, value in d.items():\n",
    "        row = value.iloc[[0]]\n",
    "        initial_class = row.ScoreClass\n",
    "        row = row.drop(['subject_id', 'visit', 'ScoreClass'], axis=1).values[0].astype(int)\n",
    "        row2 = value.iloc[[1]].drop(['subject_id', 'visit', 'ScoreClass'], axis=1).values[0].astype(int)\n",
    "        row4 = value.iloc[[3]]\n",
    "        X.append(np.concatenate([(row2-row),initial_class]))\n",
    "        y.append(int(row4.ScoreClass))\n",
    "    X_new_np = np.array(X)\n",
    "    y_new_np = np.array(y)\n",
    "    print(X_new_np.shape)\n",
    "    print(y_new_np.shape)\n",
    "    return X_new_np, y_new_np\n",
    "\n",
    "def random_forest_training(X, y, S, filename):\n",
    "    os.system(\"mkdir \" + filename)\n",
    "    forests = []\n",
    "    dataACC = []\n",
    "    dataMCC = []\n",
    "    for i in range(5):\n",
    "        logFile = open(filename + \"/\" + str(i) + \".txt\", \"w\")\n",
    "        X_tr, X_ts, y_tr, y_ts, S_tr, S_ts = splt(X, y, S, test_size=0.2, random_state=i, stratify = S)\n",
    "        rskf_ = rskf(n_splits=5, n_repeats=10, random_state=42)\n",
    "        counter = 0\n",
    "        for train_index, val_index in rskf_.split(X_tr, S_tr):\n",
    "            X_train, X_val = X_tr[train_index], X_tr[val_index]\n",
    "            y_train, y_val = y_tr[train_index], y_tr[val_index]\n",
    "            print(X_train.shape)\n",
    "            print(y_train.shape)\n",
    "            forest = rfc(n_estimators = 1000, max_depth = 100, n_jobs=-1)\n",
    "            forest.fit(X_train, y_train)\n",
    "            y_val_our = forest.predict(X_val)\n",
    "            forests.append(forest)\n",
    "            mc = mcc(y_val, y_val_our)\n",
    "            ac = acc(y_val, y_val_our)\n",
    "            logFile.write('{} Split {} Iteration: MCC: {}, ACC: {}'.format(i, counter, mc, ac))\n",
    "            counter = counter + 1\n",
    "        forest = rfc(n_estimators = 1000, max_depth = 100)\n",
    "        forest.fit(X_tr, y_tr)\n",
    "        y_ts_our = forest.predict(X_ts)\n",
    "        mc = mcc(y_ts, y_ts_our)\n",
    "        ac = acc(y_ts, y_ts_our) \n",
    "        logFile.write('Final Iteration: MCC: {}, ACC: {}'.format(mc, ac))\n",
    "        pickle.dump(forest, open(filename + \"/final-forest.pkl\", \"wb\"))\n",
    "        #mccCI = bootstrap_ci(np.array(dataMCC[i]))\n",
    "        #accCI = bootstrap_ci(np.array(dataACC[i]))\n",
    "        #logFile.write('MCC Interval: {} - {}'.format(mccCI[0], mccCI[1]))\n",
    "        #logFile.write('ACC Interval: {} - {}'.format(accCI[0], accCI[1]))\n",
    "        logFile.close()\n",
    "\n",
    "def report_everything(csvFile, headers, x_ind, y_ind, filename):\n",
    "    df = pd.read_csv(csvFile)\n",
    "    df.sort_values(\"visit\")\n",
    "    df = df.select_dtypes(exclude=['object', 'datetime64'])\n",
    "    df = df.drop(labels = ['SCORE','ana_fis:smoking_recod', 'lab:glucose', 'lab:calculated_ldl', 'lab:total_cholesterol', 'ana:age'], axis=1)\n",
    "    df = df\n",
    "    df = df[df.columns[df.max() > 0]]\n",
    "    df.head()\n",
    "    groups = df.groupby([\"ScoreClass\", \"ana:gender\"])\n",
    "    X = df.values\n",
    "    print(X.shape)\n",
    "    S = np.zeros(X.shape[0])\n",
    "    for i, (_, dfGroup) in enumerate(groups):\n",
    "        indicies = dfGroup.index.values\n",
    "        S[indicies] = i\n",
    "    \n",
    "    X_, y_ = get_data_for_trial(df, headers, x_ind, y_ind)\n",
    "    random_forest_training(X_, y_, S[0:1445], filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#X_1, y_1 = get_data_for_trial(df, [\"lab:\", \"ult_tsa:\"], [0, 1, 2, 3], [0, 1, 2, 3])\n",
    "#X_2, y_2 = get_data_for_trial(df, [\"lab:\"], [0, 1, 2, 3], [0, 1, 2, 3])\n",
    "#X_3, y_3 = get_data_for_trial(df, [\"ana_pat:\", \"ult_tsa:\"], [0, 1, 2, 3], [0, 1, 2, 3])\n",
    "#X_4, y_4 = get_data_for_trial(df, [\"ana_pat:\"], [0, 1, 2, 3], [0, 1, 2, 3])\n",
    "#X_5, y_5 = get_data_for_trial(df, [\"lab:\", \"ult_tsa:\", \"ana_pat\"], [0, 1, 2, 3], [0, 1, 2, 3])\n",
    "#random_forest_training(X_1, y_1, S, \"total_lab-ult_tsa\")\n",
    "#random_forest_training(X_2, y_2, \"total_lab\")\n",
    "#random_forest_training(X_3, y_3, \"total_ana_pat-ult_tsa\")\n",
    "#random_forest_training(X_4, y_4, \"total_ana_pat\")\n",
    "#random_forest_training(X_5, y_5, \"total_lab-ult_tsa-ana_pat\")\n",
    "report_everything(\"Data/new_wScore.csv\", None,  [0, 1, 2, 3], [0, 1, 2, 3], \"testing\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:score]",
   "language": "python",
   "name": "conda-env-score-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
}