03. Logistic Regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classification\n",
    "A classification problem is when the output variable is a category, such as “red” or “blue” or “disease” and “no disease”. A classification model attempts to draw some conclusion from observed values. Given one or more inputs a classification model will try to predict the value of one or more outcomes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logistic Regression\n",
    "\n",
    "Logistic regression is a regression model. The model builds a regression model to predict the probability that a given data entry belongs to the category numbered as “1”. Just like Linear regression assumes that the data follows a linear function, Logistic regression models the data using the sigmoid function.\n",
    "\n",
    "Linear Regression: $y = b_o + b_1x$  \n",
    "Sigmoid Function:  $p = \\frac{1}{1 + e^{-y}} $  \n",
    "Using value of y from 1st equation into 2nd  \n",
    "$ln(\\frac{p}{1 - p}) = b_o + b_1x$\n",
    "\n",
    "Logistic regression becomes a classification technique only when a decision threshold is brought into the picture. The setting of the threshold value is a very important aspect of Logistic regression and is dependent on the classification problem itself.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Issue with Linear Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we need to decide whether on tumor size vs its malignancy. Since it is a classification problem, on plotting,  all the values will lie on 0 and 1. And if we fit best found regression line, by setting the threshold at 0.5, it will give a descent result.\n",
    "<img src=\"Image/lr11.png\" width=\"400\" />\n",
    "\n",
    "But if we have an outlier, it will go horribly wrong.  \n",
    "<img src=\"Image/lr12.png\" width=\"400\" />\n",
    "\n",
    "Because of one outlier, whole linear regression prediction is going wrong.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logistic regression can be understood by standard logistic function. Logistic function is a Sigmoid function, which takes real value between zero and one.  \n",
    "If we plot sigmoid function, the graph will be S curve. \n",
    "When there is an outlier, sigmoid function takes care of it.  \n",
    "<img src=\"Image/lr13.png\" width=\"400\" />\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[65  3]\n",
      " [ 8 24]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Importing the libraries\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "# Importing the dataset\n",
    "dataset = pd.read_csv('Data/Classification/Social_Network_Ads.csv')\n",
    "\n",
    "#For 3 Independent Variables\n",
    "#map_1 = {'Male' : 1, 'Female' : 0}\n",
    "#dataset['Gender'] = dataset['Gender'].map(map_1)\n",
    "#X = dataset.iloc[:, 1:4].values\n",
    "#y = dataset.iloc[:, 4].values\n",
    "\n",
    "X = dataset.iloc[:, [2, 3]].values\n",
    "y = dataset.iloc[:, 4].values\n",
    "\n",
    "X = X.astype(float)\n",
    "y = y.astype(float)\n",
    "\n",
    "# Splitting the dataset\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)\n",
    "\n",
    "# Feature Scaling(Standardization)\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "sc_X = StandardScaler()\n",
    "X_train = sc_X.fit_transform(X_train)\n",
    "X_test = sc_X.transform(X_test)\n",
    "\n",
    "# Fitting Logistic Regression to the Training set\n",
    "#lbfgs = Limited-memory BFGS  It is a popular algorithm for parameter estimation in machine learning.\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "classifier = LogisticRegression(random_state = 0, solver='lbfgs') \n",
    "classifier.fit(X_train, y_train)\n",
    "\n",
    "# Predicting the results on Test set\n",
    "y_pred = classifier.predict(X_test)\n",
    "\n",
    "# Creating the Confusion Matrix\n",
    "from sklearn.metrics import confusion_matrix\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "print(cm)\n",
    "# https://scikit-learn.org/stable/auto_examples/neighbors/plot_nca_classification.html#sphx-glr-auto-examples-neighbors-plot-nca-classification-py\n",
    "# Visualising the Training set results\n",
    "from matplotlib.colors import ListedColormap\n",
    "#Define Variables\n",
    "clf = classifier\n",
    "h = 0.1\n",
    "X_plot, z_plot = X_train, y_train \n",
    "\n",
    "#Standard Template to draw graph\n",
    "x_min, x_max = X_plot[:, 0].min() - 1, X_plot[:, 0].max() + 1\n",
    "y_min, y_max = X_plot[:, 1].min() - 1, X_plot[:, 1].max() + 1\n",
    "xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n",
    "                     np.arange(y_min, y_max, h))\n",
    "\n",
    "\n",
    "# Plot the decision boundary. For that, we will assign a color to each\n",
    "# point in the mesh\n",
    "Z = clf.predict(np.array([xx.ravel(), yy.ravel()]).T)\n",
    "Z = Z.reshape(xx.shape)\n",
    "plt.contourf(xx, yy, Z,\n",
    "             alpha = 0.7, cmap = ListedColormap(('blue', 'red')))\n",
    "\n",
    "\n",
    "for i, j in enumerate(np.unique(z_plot)):\n",
    "    plt.scatter(X_plot[z_plot == j, 0], X_plot[z_plot == j, 1],\n",
    "                c = ['blue', 'red'][i], cmap = ListedColormap(('blue', 'red')), label = j)\n",
    "   #X[:, 0], X[:, 1] \n",
    "plt.xlim(xx.min(), xx.max())\n",
    "plt.ylim(yy.min(), yy.max())\n",
    "plt.title('Logistic Regression')\n",
    "plt.xlabel('Independent Variable 1')\n",
    "plt.ylabel('Independent Variable 2')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Confusion Matrix\n",
    "- Describe the performance of a classification model\n",
    "- Condition - True values of the test data should be known\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[65  3]\n",
      " [ 8 24]]\n",
      "\n",
      "Classification Report\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.89      0.96      0.92        68\n",
      "         1.0       0.89      0.75      0.81        32\n",
      "\n",
      "   micro avg       0.89      0.89      0.89       100\n",
      "   macro avg       0.89      0.85      0.87       100\n",
      "weighted avg       0.89      0.89      0.89       100\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "print(metrics.confusion_matrix(y_test, y_pred) )\n",
    "print(\"\")\n",
    "print(\"Classification Report\")\n",
    "print(metrics.classification_report(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Image/cm1.JPG\" width=\"300\" />\n",
    "\n",
    "- Accuracy: Is fraction of correct predictions in all prediction made by model  \n",
    "- Precision: Is fraction of correct positive predictions in all positive predictions made by the model  \n",
    "- Recall: Is fraction of correct positive predictions made in actual positive data  \n",
    "\n",
    "If your data are balanced, i.e. have nearly same number of instance in each class then you can use accuracy, else you can use precision or accuracy based on either classifying instance in positive class or negative class is more important "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Precision = $\\frac {TP}{Predicted Yes}$ = 65/73 = 0.89\n",
    "  \n",
    "Sensitivity/Recall = $\\frac {TP}{Actual Yes}$ = 65/68 = 0.96\n",
    "  \n",
    "Accuracy = $\\frac {TN+TP}{Total}$ = 89/100 = 0.89\n",
    "  \n",
    "Error Rate = $\\frac {FN+FP}{Total}$ = 11/100 = 0.11\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Relevance of Confusion Matrix\n",
    "- Spam Filter (positive class: spam): Optimize for precision or specificity because false negatives (spam goes to inbox) are more acceptable than false positives (non-spam caught by spam filter).\n",
    "\n",
    "- Fraudulent transaction detector ( positive class: fraud): Optimize for sensitivity because false positives (normal transactions that are flagged as possible fraud) are more acceptable than false negatives (fraudulent transactions that are not detected)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cross Validation\n",
    "\n",
    "- allows us to use the dataset better\n",
    "- We usually evaluate training data by test data\n",
    "- Here idea is to evaluate training data without test data\n",
    "- You just can’t fit the model to your training data and hope it would accurately work for the real data it has never seen before.\n",
    "\n",
    "<img src=\"Image/cv1.png\" width=\"300\" />\n",
    "\n",
    "- Use Test data only for final test\n",
    "Issue:\n",
    "- How do we choose the validation set?\n",
    "- Enough data?\n",
    "- Mitigate overfitting?\n",
    "<img src=\"Image/cv2.png\" width=\"300\" />\n",
    "\n",
    "## K- Fold Cross Validation Steps:\n",
    "- For each fold, determine best parameter (coefficient) value\n",
    "\n",
    "<img src=\"Image/cv3.png\" width=\"300\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import Libraries\n",
    "import pandas as pd                 # pandas is a dataframe library\n",
    "import matplotlib.pyplot as plt      # matplotlib.pyplot plots data\n",
    "%matplotlib inline\n",
    "\n",
    "#Read the data\n",
    "df = pd.read_csv(\"Data/Classification/pima-data.csv\")\n",
    "\n",
    "#Check the Correlation\n",
    "df.corr()\n",
    "#Delete the correlated feature\n",
    "del df['skin']\n",
    "\n",
    "#Data Molding\n",
    "diabetes_map = {True : 1, False : 0}\n",
    "df['diabetes'] = df['diabetes'].map(diabetes_map)\n",
    "\n",
    "#Splitting the data\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "#This will copy all columns from 0 to 7(8 - second place counts from 1)\n",
    "X = df.iloc[:, 0:8]\n",
    "y = df.iloc[:, 8]\n",
    "\n",
    "split_test_size = 0.30\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=split_test_size, random_state=42) \n",
    "\n",
    "#Imputing\n",
    "from sklearn.impute import SimpleImputer \n",
    "\n",
    "#Impute with mean all 0 readings\n",
    "fill_0 = SimpleImputer(missing_values=0, strategy=\"mean\")\n",
    "\n",
    "X_train = fill_0.fit_transform(X_train)\n",
    "X_test = fill_0.fit_transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7877094972067039"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn import metrics\n",
    "# import warnings filter\n",
    "from warnings import simplefilter\n",
    "# ignore all future warnings\n",
    "simplefilter(action='ignore', category=FutureWarning)\n",
    "\n",
    "lr_model =LogisticRegression(C=0.7, random_state=42, max_iter=150)\n",
    "lr_model.fit(X_train, y_train.ravel())\n",
    "lr_predict_test = lr_model.predict(X_test)\n",
    "lr_model.score(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6.69791720e-02,  3.92879297e-02, -9.44965378e-03,\n",
       "         3.91336082e-03,  1.91002787e-05,  1.05759743e-01,\n",
       "         2.64316581e-01,  3.41628978e-02]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#A negative coefficient means that higher value of the corresponding feature pushes the classification more towards the negative class\n",
    "lr_model.coef_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.1934069 ,  1.18297558, -0.11522356,  0.03312661,  0.00162276,\n",
       "         0.73588783,  0.09033513,  0.39883249]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Find most influential feature\n",
    "import numpy as np\n",
    "np.std(X_train, 0)*lr_model.coef_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "lr_model.score(X_train, y_train) is the training accuracy, while  \n",
    "accuracy_score(y_test, classifier.predict(X_test)) is the testing accuracy.   \n",
    "\n",
    ".score() method in the LogisticRegression class directly calls the sklearn.metrics.accuracy_score\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Apply K-Fold Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7448789571694601\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "# K Fold =3\n",
    "kfold = KFold(n_splits=3, random_state=7)\n",
    "\n",
    "#.ravel will convert that array shape to (n, )\n",
    "result = cross_val_score(lr_model, X_train, y_train.ravel(), cv=kfold, scoring='accuracy')\n",
    "print(result.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is slight decrease in score. This can be improved with hyperparameter tuning/optimization(Grid Search)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hyper-Parameter\n",
    "\n",
    "1. One which is set manually before learning process begins.\n",
    "2. Hyper-parameters are data dependent & many times need experiments to find the best\n",
    "3. GridSearch is used to find the best hyper-parameters  \n",
    "4. hyperparameter is a parameter whose value is used to control the learning process  \n",
    "  \n",
    "Examples:\n",
    "- The learning rate for training a neural network.\n",
    "- The C and sigma hyperparameters for support vector machines.\n",
    "- The k in k-nearest neighbors. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Grid Search\n",
    "* Grid-search is used to find best combination of hyperparameters for a model which results in the most 'accurate' predictions\n",
    "* The goal is then to train model on each combination of hyper paramater and evaluate them e.g. using cross-validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.763501 using {'C': 1.5, 'dual': False, 'max_iter': 100}\n",
      "Execution time: 0.7279989719390869 ms\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\rishbans\\Anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_search.py:841: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal.\n",
      "  DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "import time\n",
    "\n",
    "\n",
    "dual=[True,False]\n",
    "max_iter=[100,110,120,130,140]\n",
    "C = [1.0,1.5,2.0,2.5]\n",
    "param_grid = dict(dual=dual,max_iter=max_iter,C=C)\n",
    "lr = LogisticRegression(penalty='l2')\n",
    "grid = GridSearchCV(estimator=lr, param_grid=param_grid, cv = 3, n_jobs=-1)\n",
    "\n",
    "start_time = time.time()\n",
    "grid_result = grid.fit(X_train, y_train.ravel())\n",
    "# Summarize results\n",
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "print(\"Execution time: \" + str((time.time() - start_time)) + ' ms')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is an increase in the accuracy score, but there is a sufficient amount of growth in the execution time as well. The larger the grid, the more execution time."
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}