{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Diabetes prediction using sklearn logistic regression\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will:\n", "\n", " 1: load our diabetes dataset\n", " 2: preprocess data (normalise it)\n", " 3: split it (80:20 train:test)\n", " 4: train logistic regressor\n", " 5: test it against the test set// you can do this bit" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "#1: import relevant packages and load data file akamsdiabetes.csv\n", "#load data\n", "import pandas as pd\n", "diabetes = pd.read_csv(\"akamsdiabetes.csv\")\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
PatientIDPregnanciesPlasmaGlucoseDiastolicBloodPressureTricepsThicknessSerumInsulinBMIDiabetesPedigreeAgeDiabetic
01354778017180342343.5097261.213191210
1114743889293473621.2405760.158365230
21640031711547523541.5115230.079019230
318833509103782530429.5821921.282870431
4142411918559273542.6045360.549542220
\n", "
" ], "text/plain": [ " PatientID Pregnancies PlasmaGlucose DiastolicBloodPressure \\\n", "0 1354778 0 171 80 \n", "1 1147438 8 92 93 \n", "2 1640031 7 115 47 \n", "3 1883350 9 103 78 \n", "4 1424119 1 85 59 \n", "\n", " TricepsThickness SerumInsulin BMI DiabetesPedigree Age Diabetic \n", "0 34 23 43.509726 1.213191 21 0 \n", "1 47 36 21.240576 0.158365 23 0 \n", "2 52 35 41.511523 0.079019 23 0 \n", "3 25 304 29.582192 1.282870 43 1 \n", "4 27 35 42.604536 0.549542 22 0 " ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#quick look at our data structure\n", "diabetes.head()\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "#create train/test datasets\n", "#split 80:20\n", "from sklearn.model_selection import train_test_split\n", "train,test=train_test_split(diabetes,test_size=0.2,random_state=42)\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Int64Index: 8000 entries, 9254 to 7270\n", "Data columns (total 10 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 PatientID 8000 non-null int64 \n", " 1 Pregnancies 8000 non-null int64 \n", " 2 PlasmaGlucose 8000 non-null int64 \n", " 3 DiastolicBloodPressure 8000 non-null int64 \n", " 4 TricepsThickness 8000 non-null int64 \n", " 5 SerumInsulin 8000 non-null int64 \n", " 6 BMI 8000 non-null float64\n", " 7 DiabetesPedigree 8000 non-null float64\n", " 8 Age 8000 non-null int64 \n", " 9 Diabetic 8000 non-null int64 \n", "dtypes: float64(2), int64(8)\n", "memory usage: 687.5 KB\n" ] } ], "source": [ "#quick look at our training data structure\n", "train.info()\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Int64Index: 2000 entries, 6252 to 6929\n", "Data columns (total 8 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 Pregnancies 2000 non-null int64 \n", " 1 PlasmaGlucose 2000 non-null int64 \n", " 2 DiastolicBloodPressure 2000 non-null int64 \n", " 3 TricepsThickness 2000 non-null int64 \n", " 4 SerumInsulin 2000 non-null int64 \n", " 5 BMI 2000 non-null float64\n", " 6 DiabetesPedigree 2000 non-null float64\n", " 7 Age 2000 non-null int64 \n", "dtypes: float64(2), int64(6)\n", "memory usage: 140.6 KB\n" ] } ], "source": [ "#target is y\n", "y_train=train['Diabetic']\n", "y_test=test['Diabetic']\n", "#drop the unwanted columns, features are in X\n", "X_train=train.drop(['PatientID','Diabetic'],axis=1)\n", "X_test=test.drop(['PatientID','Diabetic'],axis=1)\n", "X_test.info()\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# normalize\n", "from sklearn.preprocessing import MinMaxScaler\n", "min_max_scaler=MinMaxScaler()\n", "X_train=min_max_scaler.fit_transform(X_train)\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[0.42857143, 0.58783784, 0.58064516, ..., 0.7318668 , 0.03992778,\n", " 0.01785714],\n", " [0.21428571, 0.7972973 , 0.6344086 , ..., 0.51321579, 0.00874833,\n", " 0.01785714],\n", " [0.07142857, 0.07432432, 0.74193548, ..., 0.49851367, 0.06168239,\n", " 0.08928571],\n", " ...,\n", " [0.42857143, 0.47297297, 0.49462366, ..., 0.07105176, 0.02107189,\n", " 0.26785714],\n", " [0.07142857, 0.41891892, 0.40860215, ..., 0.33078954, 0.01112777,\n", " 0. ],\n", " [0.21428571, 0.53378378, 0.88172043, ..., 0.70527449, 0.17353183,\n", " 0.07142857]])" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "X_train" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
LogisticRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "LogisticRegression()" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sklearn.linear_model import LogisticRegression\n", "log_res=LogisticRegression()\n", "log_res.fit(X_train,y_train)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1 0 0 ... 1 0 0]\n", "9254 1\n", "1561 0\n", "1670 0\n", "6087 0\n", "6669 0\n", " ..\n", "5734 0\n", "5191 0\n", "5390 1\n", "860 1\n", "7270 0\n", "Name: Diabetic, Length: 8000, dtype: int64\n" ] } ], "source": [ "from sklearn.model_selection import cross_val_predict\n", "\n", "y_train_pred=cross_val_predict(log_res,X_train,y_train,cv=3)\n", "print(y_train_pred)\n", "print(y_train)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[4626, 664],\n", " [1101, 1609]], dtype=int64)" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sklearn.metrics import confusion_matrix\n", "confusion_matrix(y_train,y_train_pred)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Predicted\n", " Neg Pos \n", " Actual(correct)Neg TN=4626 , FP=664\n", "\n", " Pos FN=1101 , TP=1609\n", " " ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "recall is 0.5937269372693726\n", "precision is 0.7078750549934008\n" ] } ], "source": [ "TN=4626\n", "FP=664\n", "FN=1101\n", "TP=1609\n", "recall= TP/(TP+FN) #what proportion of actual positives were correctly predicted\n", "print(\"recall is \",recall) \n", "precision = TP/(TP+FP) #what proportion of predicted positives\n", " #were correctly predicted\n", "print (\"precision is \",precision)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from sklearn.metrics import roc_curve\n", "y_scores = cross_val_predict(log_res,X_train,y_train,cv=3,method=\"decision_function\")\n", "fpr,tpr,thresholds = roc_curve(y_train,y_scores)\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "plt.plot(fpr,tpr,label=None)\n", "plt.plot([0,1],[0,1],'k--')\n", "plt.xlabel('False Positive Rate')\n", "plt.ylabel('True Positive Rate')\n", "\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Not brilliant but better than a kick in the head." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'C': 1.0,\n", " 'class_weight': None,\n", " 'dual': False,\n", " 'fit_intercept': True,\n", " 'intercept_scaling': 1,\n", " 'l1_ratio': None,\n", " 'max_iter': 100,\n", " 'multi_class': 'auto',\n", " 'n_jobs': None,\n", " 'penalty': 'l2',\n", " 'random_state': None,\n", " 'solver': 'lbfgs',\n", " 'tol': 0.0001,\n", " 'verbose': 0,\n", " 'warm_start': False}" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "log_res.get_params() " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.9.16" } }, "nbformat": 4, "nbformat_minor": 4 }