models.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "jewish-rochester",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "import statsmodels.tools.tools as stattools\n",
    "import jenkspy\n",
    "from scipy import stats\n",
    "from sklearn.model_selection import train_test_split\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import statsmodels.api as sm\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn import tree\n",
    "from sklearn.ensemble import RandomForestClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "liquid-garlic",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('E:\\\\term8\\\\datamining\\\\HW\\\\project\\\\prepared_data.csv')\n",
    "breaks = jenkspy.jenks_breaks(df['age'],nb_class = 5)\n",
    "df['agebin'] = pd.cut(x = df['age'], bins = breaks, right = False, labels = [1,2,3,4,5])\n",
    "\n",
    "breaks = jenkspy.jenks_breaks(df['bmi'],nb_class = 5)\n",
    "df['bmibin'] = pd.cut(x = df['bmi'], bins = breaks, right = False, labels = [1,2,3,4,5])\n",
    "\n",
    "breaks = jenkspy.jenks_breaks(df['avg_glucose_level'],nb_class = 5)\n",
    "df['glubin'] = pd.cut(x = df['avg_glucose_level'], bins = breaks, right = False, labels = [1,2,3,4,5])\n",
    "df = df.drop(columns = ['age', 'bmi', 'avg_glucose_level'])\n",
    "df = pd.get_dummies(df, columns = ['agebin', 'bmibin', 'glubin'])\n",
    "\n",
    "df_train, df_test = train_test_split(df, test_size = 0.2, random_state = 45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "combined-swaziland",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 6.07 ms\n",
      "Wall time: 13.5 ms\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.97      0.71      0.82       782\n",
      "           1       0.15      0.74      0.26        57\n",
      "\n",
      "    accuracy                           0.71       839\n",
      "   macro avg       0.56      0.72      0.54       839\n",
      "weighted avg       0.92      0.71      0.78       839\n",
      "\n",
      "[[552 230]\n",
      " [ 15  42]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E:\\term6\\Anaconda\\setUp\\envs\\tensorflow\\lib\\site-packages\\ipykernel_launcher.py:1: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "temp = df_train[df['stroke'] == 1]\n",
    "temp = temp.sample(n = len(df_train[df_train['stroke'] == 0]) - len(df_train[df_train['stroke'] == 1]),\n",
    "                   replace = True)#20% of data: 800\n",
    "df_train = pd.concat([df_train, temp])\n",
    "y = df_train['stroke'].values\n",
    "df_train = df_train.drop(columns = ['stroke'])\n",
    "X = df_train.values\n",
    "y_test = df_test['stroke'].values\n",
    "df_test = df_test.drop(columns = ['stroke'])\n",
    "X_test = df_test.values\n",
    "%time nb_01 = MultinomialNB().fit(X, y)\n",
    "%time y_pred = nb_01.predict(X_test)\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "legal-planning",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 39.5 ms\n",
      "Wall time: 0 ns\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.73      0.83       782\n",
      "         1.0       0.17      0.75      0.27        57\n",
      "\n",
      "    accuracy                           0.73       839\n",
      "   macro avg       0.57      0.74      0.55       839\n",
      "weighted avg       0.92      0.73      0.79       839\n",
      "\n",
      "[[568 214]\n",
      " [ 14  43]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E:\\term6\\Anaconda\\setUp\\envs\\tensorflow\\lib\\site-packages\\ipykernel_launcher.py:3: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv('E:\\\\term8\\\\datamining\\\\HW\\\\project\\\\prepared_data.csv')\n",
    "df_train, df_test = train_test_split(df, test_size = 0.2, random_state = 45) \n",
    "temp = df_train[df['stroke'] == 1]\n",
    "temp = temp.sample(n = len(df_train[df_train['stroke'] == 0]) - len(df_train[df_train['stroke'] == 1]),\n",
    "                   replace = True)#20% of data: 800\n",
    "df_train = pd.concat([df_train, temp])\n",
    "X = df_train.values[:, 0:20]\n",
    "y = df_train.values[:, 20]\n",
    "X_test = df_test.values[:, 0:20]\n",
    "y_test = df_test.values[:, 20]\n",
    "%time clf = LogisticRegression(random_state=0).fit(X, y)\n",
    "%time y_pred = (clf.predict_proba(X_test)[:,1]>0.5)*1\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "champion-light",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 1.68 s\n",
      "Wall time: 354 ms\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.73      0.83       782\n",
      "         1.0       0.16      0.70      0.26        57\n",
      "\n",
      "    accuracy                           0.73       839\n",
      "   macro avg       0.56      0.71      0.54       839\n",
      "weighted avg       0.92      0.73      0.79       839\n",
      "\n",
      "[[569 213]\n",
      " [ 17  40]]\n"
     ]
    }
   ],
   "source": [
    "%time clf = SVC(gamma='auto').fit(X, y)\n",
    "%time y_pred = clf.predict(X_test)\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "narrow-breakdown",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 3.59 s\n",
      "Wall time: 1.12 ms\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.74      0.84       782\n",
      "         1.0       0.17      0.72      0.28        57\n",
      "\n",
      "    accuracy                           0.74       839\n",
      "   macro avg       0.57      0.73      0.56       839\n",
      "weighted avg       0.92      0.74      0.80       839\n",
      "\n",
      "[[582 200]\n",
      " [ 16  41]]\n"
     ]
    }
   ],
   "source": [
    "mlp = MLPClassifier(hidden_layer_sizes=(100), max_iter=300,activation = 'relu', solver = 'adam', alpha=1)\n",
    "%time mlp.fit(X, y)\n",
    "%time y_pred = mlp.predict(X_test)\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "serial-community",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 10.7 ms\n",
      "Wall time: 997 µs\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.72      0.82       782\n",
      "         1.0       0.14      0.65      0.24        57\n",
      "\n",
      "    accuracy                           0.71       839\n",
      "   macro avg       0.55      0.68      0.53       839\n",
      "weighted avg       0.91      0.71      0.78       839\n",
      "\n",
      "[[562 220]\n",
      " [ 20  37]]\n"
     ]
    }
   ],
   "source": [
    "DT = tree.DecisionTreeClassifier(criterion = 'gini',max_depth=4)\n",
    "%time DT.fit(X,y)\n",
    "%time y_pred = DT.predict(X_test)\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "operating-tunisia",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 12.7 ms\n",
      "Wall time: 0 ns\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.69      0.80       782\n",
      "         1.0       0.13      0.67      0.22        57\n",
      "\n",
      "    accuracy                           0.69       839\n",
      "   macro avg       0.55      0.68      0.51       839\n",
      "weighted avg       0.91      0.69      0.76       839\n",
      "\n",
      "[[537 245]\n",
      " [ 19  38]]\n"
     ]
    }
   ],
   "source": [
    "DT = tree.DecisionTreeClassifier(criterion = 'entropy',max_depth=4)\n",
    "%time DT.fit(X,y)\n",
    "%time y_pred = DT.predict(X_test)\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "refined-services",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 335 ms\n",
      "Wall time: 13.9 ms\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.66      0.79       782\n",
      "         1.0       0.15      0.81      0.25        57\n",
      "\n",
      "    accuracy                           0.67       839\n",
      "   macro avg       0.56      0.74      0.52       839\n",
      "weighted avg       0.92      0.67      0.75       839\n",
      "\n",
      "[[519 263]\n",
      " [ 11  46]]\n"
     ]
    }
   ],
   "source": [
    "model = RandomForestClassifier(n_estimators=100,max_depth=4,\n",
    "                               criterion='entropy', random_state=40)\n",
    "%time model.fit(X,y)\n",
    "%time y_pred = model.predict(X_test)\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lesbian-maple",
   "metadata": {},
   "source": [
    "## subset of dataset (age under 75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "abroad-washer",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('E:\\\\term8\\\\datamining\\\\HW\\\\project\\\\prepared_data_75.csv')\n",
    "breaks = jenkspy.jenks_breaks(df['age'],nb_class = 5)\n",
    "df['agebin'] = pd.cut(x = df['age'], bins = breaks, right = False, labels = [1,2,3,4,5])\n",
    "\n",
    "breaks = jenkspy.jenks_breaks(df['bmi'],nb_class = 5)\n",
    "df['bmibin'] = pd.cut(x = df['bmi'], bins = breaks, right = False, labels = [1,2,3,4,5])\n",
    "\n",
    "breaks = jenkspy.jenks_breaks(df['avg_glucose_level'],nb_class = 5)\n",
    "df['glubin'] = pd.cut(x = df['avg_glucose_level'], bins = breaks, right = False, labels = [1,2,3,4,5])\n",
    "df = df.drop(columns = ['age', 'bmi', 'avg_glucose_level'])\n",
    "df = pd.get_dummies(df, columns = ['agebin', 'bmibin', 'glubin'])\n",
    "\n",
    "df_train, df_test = train_test_split(df, test_size = 0.2, random_state = 45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "orange-invasion",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 3.33 ms\n",
      "Wall time: 994 µs\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.69      0.81       707\n",
      "           1       0.09      0.72      0.15        29\n",
      "\n",
      "    accuracy                           0.69       736\n",
      "   macro avg       0.54      0.71      0.48       736\n",
      "weighted avg       0.95      0.69      0.78       736\n",
      "\n",
      "[[486 221]\n",
      " [  8  21]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E:\\term6\\Anaconda\\setUp\\envs\\tensorflow\\lib\\site-packages\\ipykernel_launcher.py:1: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "temp = df_train[df['stroke'] == 1]\n",
    "temp = temp.sample(n = len(df_train[df_train['stroke'] == 0]) - len(df_train[df_train['stroke'] == 1]),\n",
    "                   replace = True)#20% of data: 800\n",
    "df_train = pd.concat([df_train, temp])\n",
    "y = df_train['stroke'].values\n",
    "df_train = df_train.drop(columns = ['stroke'])\n",
    "X = df_train.values\n",
    "y_test = df_test['stroke'].values\n",
    "df_test = df_test.drop(columns = ['stroke'])\n",
    "X_test = df_test.values\n",
    "%time nb_01 = MultinomialNB().fit(X, y)\n",
    "%time y_pred = nb_01.predict(X_test)\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "willing-cancellation",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 38.1 ms\n",
      "Wall time: 0 ns\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.72      0.83       707\n",
      "         1.0       0.11      0.83      0.19        29\n",
      "\n",
      "    accuracy                           0.73       736\n",
      "   macro avg       0.55      0.77      0.51       736\n",
      "weighted avg       0.96      0.73      0.81       736\n",
      "\n",
      "[[510 197]\n",
      " [  5  24]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E:\\term6\\Anaconda\\setUp\\envs\\tensorflow\\lib\\site-packages\\ipykernel_launcher.py:3: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv('E:\\\\term8\\\\datamining\\\\HW\\\\project\\\\prepared_data_75.csv')\n",
    "df_train, df_test = train_test_split(df, test_size = 0.2, random_state = 45) \n",
    "temp = df_train[df['stroke'] == 1]\n",
    "temp = temp.sample(n = len(df_train[df_train['stroke'] == 0]) - len(df_train[df_train['stroke'] == 1]),\n",
    "                   replace = True)#20% of data: 800\n",
    "df_train = pd.concat([df_train, temp])\n",
    "X = df_train.values[:, 0:20]\n",
    "y = df_train.values[:, 20]\n",
    "X_test = df_test.values[:, 0:20]\n",
    "y_test = df_test.values[:, 20]\n",
    "%time clf = LogisticRegression(random_state=0).fit(X, y)\n",
    "%time y_pred = (clf.predict_proba(X_test)[:,1]>0.5)*1\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "close-cabinet",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 1.33 s\n",
      "Wall time: 373 ms\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.76      0.86       707\n",
      "         1.0       0.08      0.52      0.14        29\n",
      "\n",
      "    accuracy                           0.75       736\n",
      "   macro avg       0.53      0.64      0.50       736\n",
      "weighted avg       0.94      0.75      0.83       736\n",
      "\n",
      "[[540 167]\n",
      " [ 14  15]]\n"
     ]
    }
   ],
   "source": [
    "%time clf = SVC(gamma='auto').fit(X, y)\n",
    "%time y_pred = clf.predict(X_test)\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "impossible-sleep",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 3.31 s\n",
      "Wall time: 6.96 ms\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.78      0.87       707\n",
      "         1.0       0.09      0.52      0.15        29\n",
      "\n",
      "    accuracy                           0.77       736\n",
      "   macro avg       0.53      0.65      0.51       736\n",
      "weighted avg       0.94      0.77      0.84       736\n",
      "\n",
      "[[554 153]\n",
      " [ 14  15]]\n"
     ]
    }
   ],
   "source": [
    "mlp = MLPClassifier(hidden_layer_sizes=(100), max_iter=300,activation = 'relu', solver = 'adam', alpha=1)\n",
    "%time mlp.fit(X, y)\n",
    "%time y_pred = mlp.predict(X_test)\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "complimentary-capability",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 16.1 ms\n",
      "Wall time: 1.18 ms\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.77      0.86       707\n",
      "         1.0       0.10      0.62      0.17        29\n",
      "\n",
      "    accuracy                           0.76       736\n",
      "   macro avg       0.54      0.70      0.52       736\n",
      "weighted avg       0.95      0.76      0.83       736\n",
      "\n",
      "[[544 163]\n",
      " [ 11  18]]\n"
     ]
    }
   ],
   "source": [
    "DT = tree.DecisionTreeClassifier(criterion = 'gini',max_depth=4)\n",
    "%time DT.fit(X,y)\n",
    "%time y_pred = DT.predict(X_test)\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "copyrighted-raise",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 15 ms\n",
      "Wall time: 999 µs\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.62      0.76       707\n",
      "         1.0       0.08      0.79      0.14        29\n",
      "\n",
      "    accuracy                           0.63       736\n",
      "   macro avg       0.53      0.71      0.45       736\n",
      "weighted avg       0.95      0.63      0.74       736\n",
      "\n",
      "[[441 266]\n",
      " [  6  23]]\n"
     ]
    }
   ],
   "source": [
    "DT = tree.DecisionTreeClassifier(criterion = 'entropy',max_depth=4)\n",
    "%time DT.fit(X,y)\n",
    "%time y_pred = DT.predict(X_test)\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "wrong-classic",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 313 ms\n",
      "Wall time: 2.75 ms\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.76      0.86       707\n",
      "         1.0       0.11      0.72      0.19        29\n",
      "\n",
      "    accuracy                           0.76       736\n",
      "   macro avg       0.55      0.74      0.52       736\n",
      "weighted avg       0.95      0.76      0.83       736\n",
      "\n",
      "[[536 171]\n",
      " [  8  21]]\n"
     ]
    }
   ],
   "source": [
    "model = RandomForestClassifier(n_estimators=100,max_depth=4,\n",
    "                               criterion='entropy', random_state=40)\n",
    "%time model.fit(X,y)\n",
    "%time y_pred = model.predict(X_test)\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(confusion_matrix(y_test, y_pred, labels = [0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "encouraging-newport",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:tensorflow] *",
   "language": "python",
   "name": "conda-env-tensorflow-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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}