InsuranceClaimPrediction03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will import pandas to read our data from a CSV file and manipulate it for further use. We will also use numpy to convert out data into a format suitable to feed our classification model. We'll use seaborn and matplotlib for visualizations. We will then import Logistic Regression algorithm from sklearn. This algorithm will help us build our classification model. Lastly, we will use joblib available in sklearn to save our model for future use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "% matplotlib inline\n",
    " \n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.externals import joblib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have our data saved in a CSV file called insurance3r2.csv. We first read our dataset in a pandas dataframe called insuranceDF, and then use the head() function to show the first five records from our dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   age  sex     bmi  steps  children  smoker  region      charges  \\\n",
      "0   19    0  27.900   3009         0       1       3  16884.92400   \n",
      "1   18    1  33.770   3008         1       0       2   1725.55230   \n",
      "2   28    1  33.000   3009         3       0       2   4449.46200   \n",
      "3   33    1  22.705  10009         0       0       1  21984.47061   \n",
      "4   32    1  28.880   8010         0       0       1   3866.85520   \n",
      "\n",
      "   insuranceclaim  \n",
      "0               1  \n",
      "1               1  \n",
      "2               0  \n",
      "3               0  \n",
      "4               1  \n"
     ]
    }
   ],
   "source": [
    "insuranceDF = pd.read_csv('insurance3r2.csv')\n",
    "print(insuranceDF.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following features have been provided to help us predict whether a person is diabetic or not:\n",
    "\n",
    "age : age of policyholder\n",
    "sex: gender of policy holder (female=0, male=1)\n",
    "bmi: Body mass index, providing an understanding of body, weights that are relatively high or low relative to height, objective index of body weight (kg / m ^ 2) using the ratio of height to weight, ideally 18.5 to 25\n",
    "steps: average number of walking steps per day\n",
    "children: number of children / dependents of policyholder\n",
    "smoker: smoking state of policyholder (non-smoke=0;smoker=1) \n",
    "region: the residential area of policyholder in the US (northeast=0, northwest=1, southeast=2, southwest=3)\n",
    "charges: individual medical costs billed by health insurance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also make sure that our data is clean (has no null values, etc)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 1338 entries, 0 to 1337\n",
      "Data columns (total 9 columns):\n",
      "age               1338 non-null int64\n",
      "sex               1338 non-null int64\n",
      "bmi               1338 non-null float64\n",
      "steps             1338 non-null int64\n",
      "children          1338 non-null int64\n",
      "smoker            1338 non-null int64\n",
      "region            1338 non-null int64\n",
      "charges           1338 non-null float64\n",
      "insuranceclaim    1338 non-null int64\n",
      "dtypes: float64(2), int64(7)\n",
      "memory usage: 94.2 KB\n"
     ]
    }
   ],
   "source": [
    "insuranceDF.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start by finding correlation of every pair of features (and the outcome variable), and visualize the correlations using a heatmap."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                     age       sex       bmi     steps  children    smoker  \\\n",
      "age             1.000000 -0.020856  0.109272 -0.167957  0.042469 -0.025019   \n",
      "sex            -0.020856  1.000000  0.046371 -0.039470  0.017163  0.076185   \n",
      "bmi             0.109272  0.046371  1.000000 -0.681149  0.012759  0.003750   \n",
      "steps          -0.167957 -0.039470 -0.681149  1.000000  0.055346 -0.267845   \n",
      "children        0.042469  0.017163  0.012759  0.055346  1.000000  0.007673   \n",
      "smoker         -0.025019  0.076185  0.003750 -0.267845  0.007673  1.000000   \n",
      "region          0.002127  0.004588  0.157566 -0.076483  0.016569 -0.002181   \n",
      "charges         0.299008  0.057292  0.198341 -0.305570  0.067998  0.787251   \n",
      "insuranceclaim  0.113723  0.031565  0.384198 -0.419514 -0.409526  0.333261   \n",
      "\n",
      "                  region   charges  insuranceclaim  \n",
      "age             0.002127  0.299008        0.113723  \n",
      "sex             0.004588  0.057292        0.031565  \n",
      "bmi             0.157566  0.198341        0.384198  \n",
      "steps          -0.076483 -0.305570       -0.419514  \n",
      "children        0.016569  0.067998       -0.409526  \n",
      "smoker         -0.002181  0.787251        0.333261  \n",
      "region          1.000000 -0.006208        0.020891  \n",
      "charges        -0.006208  1.000000        0.309418  \n",
      "insuranceclaim  0.020891  0.309418        1.000000  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x139a9fe0400>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x139a9f32be0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "corr = insuranceDF.corr()\n",
    "print(corr)\n",
    "sns.heatmap(corr, \n",
    "        xticklabels=corr.columns,\n",
    "        yticklabels=corr.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above heatmap, brighter colors indicate more correlation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using machine learning algorithms we should always split our data into a training set and test set. (If the number of experiments we are running is large, then we can should be dividing our data into 3 parts, namely - training set, development set and test set). In our case, we will also separate out some data for manual cross checking.\n",
    "\n",
    "The data set consists of record of 1338 policy-holders in total. To train our model we will be using 1000 records. We will be using 300 records for testing, and the last 38 records to cross check our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfTrain = insuranceDF[:1000]\n",
    "dfTest = insuranceDF[1000:1300]\n",
    "dfCheck = insuranceDF[1300:] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we separate the label and features (for both training and test dataset). In addition to that, we will also convert them into NumPy arrays as our machine learning algorithm process data in NumPy array format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainLabel = np.asarray(dfTrain['insuranceclaim'])\n",
    "trainData = np.asarray(dfTrain.drop('insuranceclaim',1))\n",
    "testLabel = np.asarray(dfTest['insuranceclaim'])\n",
    "testData = np.asarray(dfTest.drop('insuranceclaim',1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the final step before using machine learning, we will normalize our inputs. Machine Learning models often benefit substantially from input normalization. It also makes it easier for us to understand the importance of each feature later, when we'll be looking at the model weights. We'll normalize the data such that each variable has 0 mean and standard deviation of 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "means = np.mean(trainData, axis=0)\n",
    "stds = np.std(trainData, axis=0)\n",
    " \n",
    "trainData = (trainData - means)/stds\n",
    "testData = (testData - means)/stds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now train our classification model. We'll be using a machine simple learning model called logistic regression. Since the model is readily available in sklearn, the training process is quite easy and we can do it in few lines of code. First, we create an instance called insuranceCheck and then use the fit function to train the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
       "          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,\n",
       "          penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\n",
       "          verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "insuranceCheck = LogisticRegression()\n",
    "insuranceCheck.fit(trainData, trainLabel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now use our test data to find out accuracy of the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy =  86.0 %\n"
     ]
    }
   ],
   "source": [
    "accuracy = insuranceCheck.score(testData, testLabel)\n",
    "print(\"accuracy = \", accuracy * 100, \"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get a better sense of what is going on inside the logistic regression model, we can visualize how our model uses the different features and which features have greater effect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'Importance')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x139ac114e48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "coeff = list(insuranceCheck.coef_[0])\n",
    "labels = list(dfTrain.drop('insuranceclaim',1).columns)\n",
    "features = pd.DataFrame()\n",
    "features['Features'] = labels\n",
    "features['importance'] = coeff\n",
    "features.sort_values(by=['importance'], ascending=True, inplace=True)\n",
    "features['positive'] = features['importance'] > 0\n",
    "features.set_index('Features', inplace=True)\n",
    "features.importance.plot(kind='barh', figsize=(11, 6),color = features.positive.map({True: 'blue', False: 'red'}))\n",
    "plt.xlabel('Importance')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the above figure, we can draw the following conclusions.\n",
    "\n",
    "1. BMI, Smoker have significant influence on the model, specially BMI. It is good to see our machine learning model match what we have been hearing from doctors our entire lives!\n",
    "\n",
    "2. Children has a negative influence on the prediction, i.e. higher number children / dependents are correlated with a policyholder not taken insurance claim.\n",
    "\n",
    "3. Although age was more correlated than BMI to the output variables (as we saw during data exploration), the model relies more on BMI. This can happen for several reasons, including the fact that the correlation captured by age is also captured by some other variable, whereas the information captured by BMI is not captured by other variables.\n",
    "\n",
    "Note that this above interpretations require that our input data is normalized. Without that, we can't claim that importance is proportional to weights."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now save our trained model for future use using joblib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['insurance01Model.pkl']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joblib.dump([insuranceCheck, means, stds], 'insurance01Model.pkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To check whether we have saved the model properly or not, we will use our test data to check the accuracy of our saved model (we should observe no change in accuracy if we have saved it properly)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy =  86.0 %\n"
     ]
    }
   ],
   "source": [
    "insuranceLoadedModel, means, stds = joblib.load('insurance01Model.pkl')\n",
    "accuracyModel = insuranceLoadedModel.score(testData, testLabel)\n",
    "print(\"accuracy = \",accuracyModel * 100,\"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now use our unused 38 data to see how predictions can be made. We have our unused data in dfCheck."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      age  sex     bmi  steps  children  smoker  region      charges  \\\n",
      "1300   45    1  30.360   4002         0       1       2  62592.87309   \n",
      "1301   62    1  30.875   4001         3       1       1  46718.16325   \n",
      "1302   25    0  20.800  10005         1       0       3   3208.78700   \n",
      "1303   43    1  27.800   4009         0       1       3  37829.72420   \n",
      "1304   42    1  24.605   8009         2       1       0  21259.37795   \n",
      "1305   24    0  27.720   8008         0       0       2   2464.61880   \n",
      "1306   29    0  21.850   3007         0       1       0  16115.30450   \n",
      "1307   32    1  28.120   4001         4       1       1  21472.47880   \n",
      "1308   25    0  30.200   3008         0       1       3  33900.65300   \n",
      "1309   41    1  32.200   3001         2       0       3   6875.96100   \n",
      "1310   42    1  26.315   8006         1       0       1   6940.90985   \n",
      "1311   33    0  26.695   8005         0       0       1   4571.41305   \n",
      "1312   34    1  42.900   4001         1       0       3   4536.25900   \n",
      "1313   19    0  34.700   4000         2       1       3  36397.57600   \n",
      "1314   30    0  23.655   4005         3       1       1  18765.87545   \n",
      "1315   18    1  28.310   8009         1       0       0  11272.33139   \n",
      "1316   19    0  20.600  10009         0       0       3   1731.67700   \n",
      "1317   18    1  53.130   3005         0       0       2   1163.46270   \n",
      "1318   35    1  39.710   3000         4       0       0  19496.71917   \n",
      "1319   39    0  26.315   8003         2       0       1   7201.70085   \n",
      "1320   31    1  31.065   4008         3       0       1   5425.02335   \n",
      "1321   62    1  26.695   5006         0       1       0  28101.33305   \n",
      "1322   62    1  38.830   3010         0       0       2  12981.34570   \n",
      "1323   42    0  40.370   4006         2       1       2  43896.37630   \n",
      "1324   31    1  25.935   8010         1       0       1   4239.89265   \n",
      "1325   61    1  33.535   3006         0       0       0  13143.33665   \n",
      "1326   42    0  32.870   4004         0       0       0   7050.02130   \n",
      "1327   51    1  30.030   4001         1       0       2   9377.90470   \n",
      "1328   23    0  24.225  10001         2       0       0  22395.74424   \n",
      "1329   52    1  38.600   3009         2       0       3  10325.20600   \n",
      "1330   57    0  25.740   8003         2       0       2  12629.16560   \n",
      "1331   23    0  33.400   3004         0       0       3  10795.93733   \n",
      "1332   52    0  44.700   4009         3       0       3  11411.68500   \n",
      "1333   50    1  30.970   4008         3       0       1  10600.54830   \n",
      "1334   18    0  31.920   3003         0       0       0   2205.98080   \n",
      "1335   18    0  36.850   3008         0       0       2   1629.83350   \n",
      "1336   21    0  25.800   8009         0       0       3   2007.94500   \n",
      "1337   61    0  29.070   8008         0       1       1  29141.36030   \n",
      "\n",
      "      insuranceclaim  \n",
      "1300               1  \n",
      "1301               1  \n",
      "1302               0  \n",
      "1303               1  \n",
      "1304               1  \n",
      "1305               1  \n",
      "1306               1  \n",
      "1307               0  \n",
      "1308               1  \n",
      "1309               0  \n",
      "1310               0  \n",
      "1311               1  \n",
      "1312               1  \n",
      "1313               1  \n",
      "1314               0  \n",
      "1315               0  \n",
      "1316               0  \n",
      "1317               1  \n",
      "1318               0  \n",
      "1319               0  \n",
      "1320               0  \n",
      "1321               1  \n",
      "1322               1  \n",
      "1323               1  \n",
      "1324               0  \n",
      "1325               1  \n",
      "1326               1  \n",
      "1327               1  \n",
      "1328               0  \n",
      "1329               1  \n",
      "1330               1  \n",
      "1331               1  \n",
      "1332               0  \n",
      "1333               0  \n",
      "1334               1  \n",
      "1335               1  \n",
      "1336               0  \n",
      "1337               1  \n"
     ]
    }
   ],
   "source": [
    "print(dfCheck.head(38))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now use the third record to make our insurance claim prediction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Insurance Claim Probability: [[0.95741143 0.04258857]]\n",
      "Insurance Claim Prediction: [0]\n"
     ]
    }
   ],
   "source": [
    "sampleData = dfCheck[2:3]\n",
    " \n",
    "# prepare sample  \n",
    "sampleDataFeatures = np.asarray(sampleData.drop('insuranceclaim',1))\n",
    "sampleDataFeatures = (sampleDataFeatures - means)/stds\n",
    " \n",
    "# predict \n",
    "predictionProbability = insuranceLoadedModel.predict_proba(sampleDataFeatures)\n",
    "prediction = insuranceLoadedModel.predict(sampleDataFeatures)\n",
    "print('Insurance Claim Probability:', predictionProbability)\n",
    "print('Insurance Claim Prediction:', prediction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}