Datasets
Models
Downloads: 1
Diff of
/Clinical Deterioration Prediction Model - KNN.ipynb
[000000]
..
[ac834f]
Switch to side-by-side view
--- a +++ b/Clinical Deterioration Prediction Model - KNN.ipynb @@ -0,0 +1,896 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "hide": true + }, + "source": [ + "import os\n", + "import pandas as pd\n", + "# ^^^ pyforest auto-imports - don't write above this line\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import os\n", + "import sklearn\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import pandas as pd\n", + "import os\n", + "\n", + "$$\n", + "\\renewcommand{\\like}{{\\cal L}}\n", + "\\renewcommand{\\loglike}{{\\ell}}\n", + "\\renewcommand{\\err}{{\\cal E}}\n", + "\\renewcommand{\\dat}{{\\cal D}}\n", + "\\renewcommand{\\hyp}{{\\cal H}}\n", + "\\renewcommand{\\Ex}[2]{E_{#1}[#2]}\n", + "\\renewcommand{\\x}{{\\mathbf x}}\n", + "\\renewcommand{\\v}[1]{{\\mathbf #1}}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Clinical Deterioration Prediction Model - KNN " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import os'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'C:\\\\Users\\\\abebu\\\\Dropbox\\\\Data Science\\\\Projects\\\\Capstone Project 1\\\\Potential Projects\\\\9. MIMIC\\\\Machine Learning'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "os.getcwd()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import os\\nimport pandas as pd'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "os.chdir(\"C://Users/abebu/Google Drive/mimic-iii-clinical-database-1.4\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import os\\nimport pandas as pd'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>Unnamed: 0.1</th>\n", + " <th>Unnamed: 0.1.1</th>\n", + " <th>SUBJECT_ID</th>\n", + " <th>HADM_ID</th>\n", + " <th>ICUSTAY_ID</th>\n", + " <th>los</th>\n", + " <th>hdeath</th>\n", + " <th>death</th>\n", + " <th>admission</th>\n", + " <th>ud</th>\n", + " <th>...</th>\n", + " <th>Sodium</th>\n", + " <th>Temp</th>\n", + " <th>Bilirubin</th>\n", + " <th>WBC</th>\n", + " <th>hr</th>\n", + " <th>gcs</th>\n", + " <th>bp</th>\n", + " <th>AGE</th>\n", + " <th>UO</th>\n", + " <th>saps2</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>268</td>\n", + " <td>110404</td>\n", + " <td>280836</td>\n", + " <td>3.2490</td>\n", + " <td>1</td>\n", + " <td>1</td>\n", + " <td>8</td>\n", + " <td>0.0</td>\n", + " <td>...</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>11.0</td>\n", + " <td>26.0</td>\n", + " <td>13.0</td>\n", + " <td>12.0</td>\n", + " <td>0.0</td>\n", + " <td>82.0</td>\n", + " </tr>\n", + " <tr>\n", + " <td>1</td>\n", + " <td>1</td>\n", + " <td>1</td>\n", + " <td>269</td>\n", + " <td>106296</td>\n", + " <td>206613</td>\n", + " <td>3.2788</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>8</td>\n", + " <td>17.0</td>\n", + " <td>...</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>5.0</td>\n", + " <td>7.0</td>\n", + " <td>0.0</td>\n", + " <td>37.0</td>\n", + " </tr>\n", + " <tr>\n", + " <td>2</td>\n", + " <td>2</td>\n", + " <td>2</td>\n", + " <td>270</td>\n", + " <td>188028</td>\n", + " <td>220345</td>\n", + " <td>2.8939</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0.0</td>\n", + " <td>...</td>\n", + " <td>0.0</td>\n", + " <td>3.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>11.0</td>\n", + " <td>0.0</td>\n", + " <td>13.0</td>\n", + " <td>18.0</td>\n", + " <td>0.0</td>\n", + " <td>45.0</td>\n", + " </tr>\n", + " <tr>\n", + " <td>3</td>\n", + " <td>3</td>\n", + " <td>3</td>\n", + " <td>271</td>\n", + " <td>173727</td>\n", + " <td>249196</td>\n", + " <td>2.0600</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>8</td>\n", + " <td>0.0</td>\n", + " <td>...</td>\n", + " <td>0.0</td>\n", + " <td>3.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>7.0</td>\n", + " <td>0.0</td>\n", + " <td>24.0</td>\n", + " </tr>\n", + " <tr>\n", + " <td>4</td>\n", + " <td>4</td>\n", + " <td>4</td>\n", + " <td>272</td>\n", + " <td>164716</td>\n", + " <td>210407</td>\n", + " <td>1.6202</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>8</td>\n", + " <td>0.0</td>\n", + " <td>...</td>\n", + " <td>0.0</td>\n", + " <td>3.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>5.0</td>\n", + " <td>12.0</td>\n", + " <td>0.0</td>\n", + " <td>28.0</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>5 rows × 24 columns</p>\n", + "</div>" + ], + "text/plain": [ + " Unnamed: 0.1 Unnamed: 0.1.1 SUBJECT_ID HADM_ID ICUSTAY_ID los \\\n", + "0 0 0 268 110404 280836 3.2490 \n", + "1 1 1 269 106296 206613 3.2788 \n", + "2 2 2 270 188028 220345 2.8939 \n", + "3 3 3 271 173727 249196 2.0600 \n", + "4 4 4 272 164716 210407 1.6202 \n", + "\n", + " hdeath death admission ud ... Sodium Temp Bilirubin WBC hr \\\n", + "0 1 1 8 0.0 ... 0.0 0.0 0.0 0.0 11.0 \n", + "1 0 0 8 17.0 ... 0.0 0.0 0.0 0.0 0.0 \n", + "2 0 0 0 0.0 ... 0.0 3.0 0.0 0.0 11.0 \n", + "3 0 0 8 0.0 ... 0.0 3.0 0.0 0.0 0.0 \n", + "4 0 0 8 0.0 ... 0.0 3.0 0.0 0.0 0.0 \n", + "\n", + " gcs bp AGE UO saps2 \n", + "0 26.0 13.0 12.0 0.0 82.0 \n", + "1 0.0 5.0 7.0 0.0 37.0 \n", + "2 0.0 13.0 18.0 0.0 45.0 \n", + "3 0.0 0.0 7.0 0.0 24.0 \n", + "4 0.0 5.0 12.0 0.0 28.0 \n", + "\n", + "[5 rows x 24 columns]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "saps = pd.read_csv(\"saps_ts.csv\", header=0, index_col=0)\n", + "saps.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Unnamed: 0.1',\n", + " 'Unnamed: 0.1.1',\n", + " 'SUBJECT_ID',\n", + " 'HADM_ID',\n", + " 'ICUSTAY_ID',\n", + " 'los',\n", + " 'hdeath',\n", + " 'death',\n", + " 'admission',\n", + " 'ud',\n", + " 'bun',\n", + " 'Bicarbonate',\n", + " 'ventilation',\n", + " 'Potassium',\n", + " 'Sodium',\n", + " 'Temp',\n", + " 'Bilirubin',\n", + " 'WBC',\n", + " 'hr',\n", + " 'gcs',\n", + " 'bp',\n", + " 'AGE',\n", + " 'UO',\n", + " 'saps2']" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(saps.columns)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "saps=saps.drop(['Unnamed: 0.1','Unnamed: 0.1.1'], axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dimensions of y before reshaping: (61117,)\n", + "Dimensions of X before reshaping: (61117, 15)\n" + ] + } + ], + "source": [ + "# Create arrays for features and target variable\n", + "y = saps['hdeath'].values\n", + "X = saps[['admission', 'ud', 'bun', 'Bicarbonate', 'ventilation', 'Potassium', 'Sodium', 'Temp', 'Bilirubin', 'WBC', 'hr', 'gcs', 'bp', 'AGE', 'UO']].values\n", + "\n", + "# Print the dimensions of X and y before reshaping\n", + "print(\"Dimensions of y before reshaping: {}\".format(y.shape))\n", + "print(\"Dimensions of X before reshaping: {}\".format(X.shape))\n", + "\n", + "# Reshape X and y\n", + "#y = y.reshape(-1, 1)\n", + "#X = X.reshape(-1, 1)\n", + "\n", + "#Print the dimensions of X and y after reshaping\n", + "#print(\"Dimensions of y after reshaping: {}\".format(y.shape))\n", + "#print(\"Dimensions of X after reshaping: {}\".format(X.shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 8., 0., 6., ..., 13., 12., 0.],\n", + " [ 8., 17., 0., ..., 5., 7., 0.],\n", + " [ 0., 0., 0., ..., 13., 18., 0.],\n", + " ...,\n", + " [ 0., 0., 0., ..., 5., 7., 0.],\n", + " [ 0., 0., 0., ..., 13., 12., 0.],\n", + " [ 8., 0., 0., ..., 5., 0., 0.]])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n", + " metric_params=None, n_jobs=None, n_neighbors=6, p=2,\n", + " weights='uniform')" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.neighbors import KNeighborsClassifier\n", + "knn=KNeighborsClassifier(n_neighbors=6)\n", + "knn.fit(X,y)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prediction: [0]\n" + ] + } + ], + "source": [ + "# Predict the labels for the training data X\n", + "y_pred = knn.predict(X)\n", + "\n", + "# Predict and print the label for the new data point X_new\n", + "new_prediction = knn.predict([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]])\n", + "print(\"Prediction: {}\".format(new_prediction))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prediction: [1]\n" + ] + } + ], + "source": [ + "# Predict and print the label for the new data point X_new\n", + "new_prediction = knn.predict([[8,8,8,8,8,8,8,8,8,8,8,8,8,8,8]])\n", + "print(\"Prediction: {}\".format(new_prediction))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prediction: [0]\n" + ] + } + ], + "source": [ + "# Predict and print the label for the new data point X_new\n", + "new_prediction = knn.predict([[8,0,8,0,8,0,8,0,0,8,0,8,0,0,0]])\n", + "print(\"Prediction: {}\".format(new_prediction))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Accuracy: 0.924405694116547\n", + "Testing Accuracy: 0.9198298429319371\n" + ] + } + ], + "source": [ + "# Import necessary modules\n", + "from sklearn.neighbors import KNeighborsClassifier\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "\n", + "# Split into training and test set\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state=42, stratify=y)\n", + "\n", + "# Create a k-NN classifier with 10 neighbors: knn\n", + "knn = KNeighborsClassifier(n_neighbors=10)\n", + "\n", + "# Fit the classifier to the training data\n", + "knn.fit(X_train, y_train)\n", + "\n", + "# Print the accuracy\n", + "print('Training Accuracy: {}'.format(knn.score(X_train,y_train)))\n", + "print('Testing Accuracy: {}'.format(knn.score(X_test, y_test)))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Accuracy: 0.924405694116547\n", + "Testing Accuracy: 0.9198298429319371\n" + ] + } + ], + "source": [ + "from sklearn.metrics import accuracy_score\n", + "print('Training Accuracy: {}'.format((accuracy_score(knn.predict(X_train), y_train))))\n", + "print('Testing Accuracy: {}'.format((accuracy_score(knn.predict(X_test), y_test))))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Accuracy: 0.9249176773771296\n", + "Testing Accuracy: 0.9198298429319371\n" + ] + } + ], + "source": [ + "# Import necessary modules\n", + "from sklearn.neighbors import KNeighborsClassifier\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "\n", + "# Split into training and test set\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state=42, stratify=y)\n", + "\n", + "# Create a k-NN classifier with 7 neighbors: knn\n", + "knn = KNeighborsClassifier(n_neighbors=7)\n", + "\n", + "# Fit the classifier to the training data\n", + "knn.fit(X_train, y_train)\n", + "\n", + "# Print the accuracy\n", + "print('Training Accuracy: {}'.format(knn.score(X_train,y_train)))\n", + "print('Testing Accuracy: {}'.format(knn.score(X_test, y_test)))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np\\nimport matplotlib.pyplot as plt\\nimport os\\nimport pandas as pd'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np\\nimport matplotlib.pyplot as plt\\nimport os\\nimport pandas as pd'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np\\nimport matplotlib.pyplot as plt\\nimport os\\nimport pandas as pd'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np\\nimport matplotlib.pyplot as plt\\nimport os\\nimport pandas as pd'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np\\nimport matplotlib.pyplot as plt\\nimport os\\nimport pandas as pd'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np\\nimport matplotlib.pyplot as plt\\nimport os\\nimport pandas as pd'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np\\nimport matplotlib.pyplot as plt\\nimport os\\nimport pandas as pd'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np\\nimport matplotlib.pyplot as plt\\nimport os\\nimport pandas as pd'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np\\nimport matplotlib.pyplot as plt\\nimport os\\nimport pandas as pd'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np\\nimport matplotlib.pyplot as plt\\nimport os\\nimport pandas as pd'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + " if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import numpy as np\\nimport matplotlib.pyplot as plt\\nimport os\\nimport pandas as pd'); }\n", + " " + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 720x432 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Setup arrays to store train and test accuracies\n", + "neighbors = np.arange(1, 11)\n", + "train_accuracy = np.empty(len(neighbors))\n", + "test_accuracy = np.empty(len(neighbors))\n", + "\n", + "# Loop over different values of k\n", + "for i, k in enumerate(neighbors):\n", + " # Setup a k-NN Classifier with k neighbors: knn\n", + " knn = KNeighborsClassifier(n_neighbors=k)\n", + "\n", + " # Fit the classifier to the training data\n", + " knn.fit(X_train, y_train)\n", + " \n", + " #Compute accuracy on the training set\n", + " train_accuracy[i] = knn.score(X_train, y_train)\n", + "\n", + " #Compute accuracy on the testing set\n", + " test_accuracy[i] = knn.score(X_test, y_test)\n", + "\n", + "# Generate plot\n", + "plt.figure(figsize=(10,6))\n", + "plt.title('k-NN: Varying Number of Neighbors')\n", + "plt.plot(neighbors, test_accuracy, label = 'Testing Accuracy')\n", + "plt.plot(neighbors, train_accuracy, label = 'Training Accuracy')\n", + "plt.legend()\n", + "plt.xlabel('Number of Neighbors')\n", + "plt.ylabel('Accuracy')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[21404 421]\n", + " [ 1586 1036]]\n", + " precision recall f1-score support\n", + "\n", + " 0 0.93 0.98 0.96 21825\n", + " 1 0.71 0.40 0.51 2622\n", + "\n", + " accuracy 0.92 24447\n", + " macro avg 0.82 0.69 0.73 24447\n", + "weighted avg 0.91 0.92 0.91 24447\n", + "\n" + ] + } + ], + "source": [ + "# Import necessary modules\n", + "from sklearn.metrics import classification_report\n", + "from sklearn.metrics import confusion_matrix\n", + "\n", + "# Create training and test set\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size =0.4, random_state=42)\n", + "\n", + "# Instantiate a k-NN classifier: knn\n", + "knn = KNeighborsClassifier (n_neighbors=7)\n", + "\n", + "# Fit the classifier to the training data\n", + "knn.fit(X_train, y_train)\n", + "\n", + "# Predict the labels of the test data: y_pred\n", + "y_pred = knn.predict(X_test)\n", + "\n", + "# Generate the confusion matrix and classification performance report\n", + "print(confusion_matrix(y_test, y_pred))\n", + "print(classification_report(y_test, y_pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the support column - the firgures represent the number of ICU patients in the test set on which 21,825 are ICU stay survivors and 2,622 are non-survivors (deceased). \n", + "\n", + "Our model shows 92% accuracy - represents the number of correctly classified (True positive and true negative) over the total number of data instances (true positive, false positive, true negative, and false negative). \n", + "\n", + "Precision (positive predicitve value) in classifying the data instances. Defined as true positive over true positive plus false positive. Our model have a 93% precision in classifying ICU stay survivors as survivors and a 71% precision classifying ICU patient deaths correctly. \n", + "\n", + "Recall (sensetivity or ture positive rate). Defined as true positive over true positive plus false negative. 100% recall means there is zero false negative. Our model have a high (98%) recall classifying ICU stay survivors (there only 2% false negative - survivors clasfied as deceased. Model sensetivity classifying deceased is only 40%, that is 60% fase negative - deceased classified as survivors. \n", + "\n", + "so, ideally in a good classifier, we want a metric that takes into account both precision and recall. We have f1-score for that. f1-score becomes high only if both precision and recall becomes high. Our model shows f1-score of 96% for classifying survivors and 51% classifying deceased. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}