Logistic Regression Exercise.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "deedbda5",
   "metadata": {
    "deletable": false
   },
   "source": [
    "# Objectives\n",
    "  In this Exercise you will have to complete the codes with the knowledge you have gained so far about Cost functions, Gradient decent, sigmoid function.\n",
    "  \n",
    "\n",
    "## Contents\n",
    "- [ 1 - Packages ](#1)\n",
    "- [ 2 - Logistic Regression](#2)\n",
    "  - [ 2.1 Problem Statement](#2.1)\n",
    "  - [ 2.2 Loading and visualizing the data](#2.2)\n",
    "  - [ 2.3  Sigmoid function](#2.3)\n",
    "  - [ 2.4 Cost function for logistic regression](#2.4)\n",
    "  - [ 2.5 Gradient for logistic regression](#2.5)\n",
    "  - [2.6 Learning parameters using gradient descent](#2.6)\n",
    "  - [2.7 Plotting the decision boundary](#2.7)\n",
    "  - [2.8 Evaluating logistic regression](#2.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ef25aa8",
   "metadata": {
    "deletable": false
   },
   "source": [
    "<a name=\"1\"></a>\n",
    "## 1 - Packages \n",
    "\n",
    "First, let's run the cell below to import all the packages that you will need during this assignment.\n",
    "- [numpy](www.numpy.org) is the fundamental package for scientific computing with Python.\n",
    "- [matplotlib](http://matplotlib.org) is a famous library to plot graphs in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "09b66e35",
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "# Import all necessary libraies\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import copy\n",
    "import math\n",
    "from labbuddy import *\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60070222",
   "metadata": {
    "deletable": false
   },
   "source": [
    "<a name=\"2\"></a>\n",
    "## 2 - Logistic Regression\n",
    "In this part of the exercise, you will build a logistic regression model to predict whether a student gets admitted into a university.\n",
    "\n",
    "<a name=\"2.1\"></a>\n",
    "### 2.1 Problem Statement\n",
    "\n",
    "Suppose that you are the administrator of a university department and you want to determine each applicant’s chance of admission based on their results on two exams. \n",
    "* You have historical data from previous applicants that you can use as a training set for logistic regression. \n",
    "* For each training example, you have the applicant’s scores on two exams and the admissions decision. \n",
    "* Your task is to build a classification model that estimates an applicant’s probability of admission based on the scores from those two exams. \n",
    "\n",
    "<a name=\"2.2\"></a>\n",
    "### 2.2 Loading and visualizing the data\n",
    "\n",
    "You will start by loading the dataset for this task. \n",
    "- Below cell loads the data into variables `x_train` and `y_train`\n",
    "  - `x_train` contains exam scores on two exams for a student\n",
    "  - `y_train` is the admission decision \n",
    "      - `y_train = 1` if the student was admitted \n",
    "      - `y_train = 0` if the student was not admitted \n",
    "  - Both `x_train` and `y_train` are numpy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ba7edd53",
   "metadata": {
    "deletable": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[34.62365962 78.02469282]\n",
      " [30.28671077 43.89499752]\n",
      " [35.84740877 72.90219803]\n",
      " [60.18259939 86.3085521 ]]\n",
      "[0 0 0 1]\n"
     ]
    }
   ],
   "source": [
    "# In this we are going to train our model with 80% of data and 20% of data will be use to test the accurancy of the model\n",
    "x_train,x_test,y_train,y_test=load_data(path=\"Dataset.csv\",target=\"Admitted\",train_size=0.8,neglect_feature=[])\n",
    "print(x_train[:4])\n",
    "print(y_train[:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcbd8cd8",
   "metadata": {},
   "source": [
    "#### Visualize your data\n",
    "\n",
    "Before starting to implement any learning algorithm, it is always good to visualize the data if possible.\n",
    "- The code below displays the data on a 2D plot (as shown below), where the axes are the two exam scores, and the positive and negative examples are shown with different markers.\n",
    "- Don't feel lonely while you have a helper module ``labbuddy.py`` which always help you to visualize your dataset so that you can apply your knowledge more effectively. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c42026e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_data(x_train,y_train,\"sub1\",\"sub2\",\"Admitted\",\"Not Admitted\",True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0525e90",
   "metadata": {},
   "source": [
    "Your goal is to build a logistic regression model to fit this data.\n",
    "- With this model, you can then predict if a new student will be admitted based on their scores on the two exams.\n",
    ">Note:Try your best and if you feel any problem then simply click the `Hints` to get some hints to solve the problem"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44404c51",
   "metadata": {},
   "source": [
    "<a name=\"2.3\"></a>\n",
    "### 2.3  Sigmoid function\n",
    "\n",
    "Recall that for logistic regression, the model is represented as\n",
    "\n",
    "$$ f_{\\mathbf{w},b}(x) = g(\\mathbf{w}\\cdot \\mathbf{x} + b)$$\n",
    "where function $g$ is the sigmoid function. The sigmoid function is defined as:\n",
    "\n",
    "$$g(z) = \\frac{1}{1+e^{-z}}$$\n",
    "\n",
    "Let's implement the sigmoid function first, so it can be used by the rest of this assignment.\n",
    "\n",
    "<a name='ex-01'></a>\n",
    "### Exercise 1\n",
    "Please complete  the `sigmoid` function to calculate\n",
    "\n",
    "$$g(z) = \\frac{1}{1+e^{-z}}$$\n",
    "\n",
    "Note that \n",
    "- `z` is not always a single number, but can also be an array of numbers. \n",
    "- If the input is an array of numbers, we'd like to apply the sigmoid function to each value in the input array.\n",
    "\n",
    "If you get stuck, you can check out the hints presented after the cell below to help you with the implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3d299228",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    \"\"\"\n",
    "    Compute the sigmoid of z\n",
    "\n",
    "    Args:\n",
    "        z (ndarray): A scalar, numpy array of any size.\n",
    "\n",
    "    Returns:\n",
    "        g (ndarray): sigmoid(z), with the same shape as z\n",
    "         \n",
    "    \"\"\"\n",
    "          \n",
    "    ### START CODE HERE ###\n",
    "\n",
    "    \n",
    "    \n",
    "    \n",
    "    ### END SOLUTION ###  \n",
    "    \n",
    "    return g"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f620daf",
   "metadata": {},
   "source": [
    "<details>\n",
    "  <summary><font size=\"3\" color=\"darkgreen\"><b>Hints</b></font></summary>\n",
    "       \n",
    "   * `numpy` has a function called [`np.exp()`](https://numpy.org/doc/stable/reference/generated/numpy.exp.html), which offers a convinient way to calculate the exponential ( $e^{z}$) of all elements in the input array (`z`).\n",
    " \n",
    "<details>\n",
    "          <summary><font size=\"2\" color=\"darkblue\"><b> Click for more hints</b></font></summary>\n",
    "        \n",
    "  - You can translate $e^{-z}$ into code as `np.exp(-z)` \n",
    "    \n",
    "  - You can translate $1/e^{-z}$ into code as `1/np.exp(-z)` \n",
    "    \n",
    "    If you're still stuck, you can check the hints presented below to figure out how to calculate `g` \n",
    "    \n",
    "    <details>\n",
    "          <summary><font size=\"2\" color=\"darkorange\"><b>Hint to calculate g</b></font></summary>\n",
    "        <code>g = 1 / (1 + np.exp(-z))</code>\n",
    "    </details>\n",
    "\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1ef8e04a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigmoid(0) = 0.5\n",
      "sigmoid([1,0,2,-5,3,-3]) =[0.73105858 0.5        0.88079708 0.00669285 0.95257413 0.04742587] \n"
     ]
    }
   ],
   "source": [
    "# Let's try your sigmoid function\n",
    "value = 0\n",
    "\n",
    "print (f\"sigmoid({value}) = {sigmoid(value)}\")\n",
    "print (f\"sigmoid([1,0,2,-5,3,-3]) ={sigmoid(np.array([1,0,2,-5,3,-3]))} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3215dcc3",
   "metadata": {},
   "source": [
    "**Expected Outputs**:\n",
    "<table>\n",
    "  <tr>\n",
    "    <td> <b>sigmoid(0)<b></td>\n",
    "    <td> 0.5 </td> \n",
    "  </tr>\n",
    "</table>\n",
    "<table>\n",
    "  <tr>\n",
    "          <td><b>sigmoid([1,0,2,-5,3,-3])<b></tb>\n",
    "          <tb>[0.73105858   0.5    0.88079708 0.00669285 0.95257413 0.04742587]</tb>\n",
    "  </tr>\n",
    "        \n",
    "</table>\n",
    "    \n",
    "- As mentioned before, your code should also work with vectors and matrices. For a matrix, your function should perform the sigmoid function on every element."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2c34693",
   "metadata": {},
   "source": [
    "<a name=\"2.4\"></a>\n",
    "### 2.4 Cost function for logistic regression\n",
    "\n",
    "In this section, you will implement the cost function for logistic regression.\n",
    "\n",
    "<a name='ex-02'></a>\n",
    "### Exercise 2\n",
    "\n",
    "Please complete the `cost` function using the equations below.\n",
    "\n",
    "Recall that for logistic regression, the cost function is of the form \n",
    "\n",
    "$$ J(\\mathbf{w},b) = \\frac{1}{m}\\sum_{i=0}^{m-1} \\left[ loss(f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}), y^{(i)}) \\right] \\tag{1}$$\n",
    "\n",
    "where\n",
    "* m is the number of training examples in the dataset\n",
    "\n",
    "\n",
    "* $loss(f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}), y^{(i)})$ is the cost for a single data point, which is - \n",
    "\n",
    "    $$loss(f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}), y^{(i)}) = (-y^{(i)} \\log\\left(f_{\\mathbf{w},b}\\left( \\mathbf{x}^{(i)} \\right) \\right) - \\left( 1 - y^{(i)}\\right) \\log \\left( 1 - f_{\\mathbf{w},b}\\left( \\mathbf{x}^{(i)} \\right) \\right) \\tag{2}$$\n",
    "    \n",
    "    \n",
    "*  $f_{\\mathbf{w},b}(\\mathbf{x}^{(i)})$ is the model's prediction, while $y^{(i)}$, which is the actual label\n",
    "\n",
    "*  $f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) = g(\\mathbf{w} \\cdot \\mathbf{x^{(i)}} + b)$ where function $g$ is the sigmoid function.\n",
    "\n",
    "Note:\n",
    "* As you are doing this, remember that the variables `X_train` and `y_train` are not scalar values but matrices of shape ($m, n$) and ($𝑚$,1) respectively, where  $𝑛$ is the number of features and $𝑚$ is the number of training examples.\n",
    "* You can use the sigmoid function that you implemented above for this part.\n",
    "\n",
    "If you get stuck, you can check out the hints presented after the cell below to help you with the implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "71e2e7bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cost(x, y, w, b):\n",
    "    \"\"\"\n",
    "    Computes the cost over all examples\n",
    "    Args:\n",
    "      X : (ndarray Shape (m,n)) data, m examples by n features\n",
    "      y : (ndarray Shape (m,))  target value \n",
    "      w : (ndarray Shape (n,))  values of parameters of the model      \n",
    "      b : (scalar) value of bias parameter of the model\n",
    "    Returns:\n",
    "      total_cost : (scalar) cost \n",
    "    \"\"\"\n",
    "\n",
    "    m, n = x.shape\n",
    "    \n",
    "    ### STARTCODE HERE ###\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    ### END CODE HERE ### \n",
    "\n",
    "    return total_cost"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58f05148",
   "metadata": {},
   "source": [
    "<details>\n",
    "  <summary><font size=\"3\" color=\"darkgreen\"><b>Hints</b></font></summary>\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "  * You can represent a summation operator eg: $h = \\sum\\limits_{i = 0}^{m-1} 2i$ in code as follows:\n",
    "    ```python\n",
    "        h = 0\n",
    "        for i in range(m):\n",
    "            h = h + 2*i\n",
    "    ```\n",
    "  \n",
    "   * In this case, you can iterate over all the examples in `x` using a for loop and add the `loss` from each iteration to a variable (`loss_sum`) initialized outside the loop.\n",
    "\n",
    "   * Then, you can return the `total_cost` as `loss_sum` divided by `m`.\n",
    "   * If you are new to Python, please check that your code is properly indented with consistent spaces or tabs. Otherwise, it might produce a different output or raise an `IndentationError: unexpected indent` error.\n",
    "    <details>\n",
    "          <summary><font size=\"2\" color=\"darkblue\"><b> Click for more hints</b></font></summary>\n",
    "        * Here's how you can structure the overall implementation for this function            \n",
    "        ```python \n",
    "        def cost(x, y, w, b):\n",
    "            m, n =x.shape\n",
    "\n",
    "            ### START CODE HERE ###\n",
    "            loss_sum = 0 \n",
    "\n",
    "            # Loop over each training example\n",
    "            for i in range(m): \n",
    "\n",
    "                # First calculate z_wb = w[0]*x[i][0]+...+w[n-1]*x[i][n-1]+b\n",
    "                z_wb = 0 \n",
    "                # Loop over each feature\n",
    "                for j in range(n): \n",
    "                    # Add the corresponding term to z_wb\n",
    "                    z_wb_ij = # Your code here to calculate w[j] * x[i][j]\n",
    "                    z_wb += z_wb_ij # equivalent to z_wb = z_wb + z_wb_ij\n",
    "                # Add the bias term to z_wb\n",
    "                z_wb += b # equivalent to z_wb = z_wb + b\n",
    "\n",
    "                f_wb = # Your code here to calculate prediction f_wb for a training example\n",
    "                loss =  # Your code here to calculate loss for a training example\n",
    "\n",
    "                loss_sum += loss # equivalent to loss_sum = loss_sum + loss\n",
    "\n",
    "            total_cost = (1 / m) * loss_sum  \n",
    "            ### END CODE HERE ### \n",
    "\n",
    "            return total_cost\n",
    "        ```\n",
    "        If you're still stuck, you can check the hints presented below to figure out how to calculate `z_wb_ij`, `f_wb` and `cost`.\n",
    "        <details>\n",
    "          <summary><font size=\"2\" color=\"darkorange\"><b>Hint to calculate z_wb_ij</b></font></summary>\n",
    "            <table>\n",
    "              <tr>\n",
    "                  <td>`z_wb_ij = w[j]*x[i][j]`</td>\n",
    "              </tr>\n",
    "            </table>\n",
    "        </details>\n",
    "        <details>\n",
    "          <summary><font size=\"2\" color=\"darkorange\"><b>Hint to calculate f_wb</b></font></summary>\n",
    "           &emsp; &emsp; $f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) = g(z_{\\mathbf{w},b}(\\mathbf{x}^{(i)}))$ where $g$ is the sigmoid function. You can simply call the `sigmoid` function implemented above.\n",
    "          <details>\n",
    "              <summary><font size=\"2\" color=\"red\"><b>&emsp; &emsp; More hints to calculate f</b></font></summary>\n",
    "               &emsp; &emsp; You can compute f_wb as <code>f_wb = sigmoid(z_wb) </code>\n",
    "           </details>\n",
    "       </details>\n",
    "       <details>\n",
    "          <summary><font size=\"2\" color=\"darkorange\"><b>Hint to calculate loss</b></font></summary>\n",
    "          &emsp; &emsp; You can use the <a href=\"https://numpy.org/doc/stable/reference/generated/numpy.log.html\">np.log</a> function to calculate the log\n",
    "          <details>\n",
    "              <summary><font size=\"2\" color=\"red\"><b>&emsp; &emsp; More hints to calculate loss</b></font></summary>\n",
    "              &emsp; &emsp; You can compute loss as <code>loss =-y[i] * np.log(f_wb)-(1 -y[i])* np.log(1 - f_wb)</code>\n",
    "          </details>\n",
    "        </details>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7da36f48",
   "metadata": {},
   "source": [
    "Run the cells below to check your implementation of the `cost` function with two different initializations of the parameters $w$ and $b$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "68e8a044",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost at initial w and b (zeros): 0.693\n",
      "Cost at test w and b (non-zeros): 0.231\n"
     ]
    }
   ],
   "source": [
    "m, n = x_train.shape\n",
    "\n",
    "# Compute and display cost with w and b initialized to zeros\n",
    "w1 = np.zeros(n)\n",
    "b1 = 0\n",
    "cost1 =cost(x_train, y_train, w1, b1)\n",
    "w2 = np.array([0.2, 0.2])\n",
    "b2 = -24.\n",
    "cost2 = cost(x_train, y_train, w2,b2)\n",
    "\n",
    "print('Cost at initial w and b (zeros): {:.3f}'.format(cost1))\n",
    "print('Cost at test w and b (non-zeros): {:.3f}'.format(cost2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "907b0170",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "<table>\n",
    "  <tr>\n",
    "    <td> <b>Cost at initial w and b (zeros)<b></td>\n",
    "    <td> 0.693 </td> \n",
    "  </tr>\n",
    "</table>\n",
    "<table>\n",
    "  <tr>\n",
    "    <td> <b>Cost at test w and b (non-zeros):<b></td>\n",
    "    <td> 0.218 </td> \n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dad8ea93",
   "metadata": {},
   "source": [
    "<a name=\"2.5\"></a>\n",
    "### 2.5 Gradient for logistic regression\n",
    "\n",
    "In this section, you will implement the gradient for logistic regression.\n",
    "\n",
    "Recall that the gradient descent algorithm is:\n",
    "\n",
    "$$\\begin{align*}& \\text{repeat until convergence:} \\; \\lbrace \\newline \\; & b := b -  \\alpha \\frac{\\partial J(\\mathbf{w},b)}{\\partial b} \\newline       \\; & w_j := w_j -  \\alpha \\frac{\\partial J(\\mathbf{w},b)}{\\partial w_j} \\tag{1}  \\; & \\text{for j := 0..n-1}\\newline & \\rbrace\\end{align*}$$\n",
    "\n",
    "where, parameters $b$, $w_j$ are all updated simultaniously"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a66068ec",
   "metadata": {},
   "source": [
    "\n",
    "<a name='ex-03'></a>\n",
    "### Exercise 3\n",
    "\n",
    "Please complete the `gradient` function to compute $\\frac{\\partial J(\\mathbf{w},b)}{\\partial w}$, $\\frac{\\partial J(\\mathbf{w},b)}{\\partial b}$ from equations (2) and (3) below.\n",
    "\n",
    "$$\n",
    "\\frac{\\partial J(\\mathbf{w},b)}{\\partial b}  = \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - \\mathbf{y}^{(i)}) \\tag{2}\n",
    "$$\n",
    "$$\n",
    "\\frac{\\partial J(\\mathbf{w},b)}{\\partial w_j}  = \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - \\mathbf{y}^{(i)})x_{j}^{(i)} \\tag{3}\n",
    "$$\n",
    "* m is the number of training examples in the dataset\n",
    "\n",
    "    \n",
    "*  $f_{\\mathbf{w},b}(x^{(i)})$ is the model's prediction, while $y^{(i)}$ is the actual label\n",
    "\n",
    "\n",
    "- **Note**: While this gradient looks identical to the linear regression gradient, the formula is actually different because linear and logistic regression have different definitions of $f_{\\mathbf{w},b}(x)$.\n",
    "\n",
    "As before, you can use the sigmoid function that you implemented above and if you get stuck, you can check out the hints presented after the cell below to help you with the implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "20cfb5d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_gradient(X, y, w,b): \n",
    "    \"\"\"\n",
    "    Computes the gradient for logistic regression \n",
    " \n",
    "    Args:\n",
    "      X : (ndarray Shape (m,n)) data, m examples by n features\n",
    "      y : (ndarray Shape (m,))  target value \n",
    "      w : (ndarray Shape (n,))  values of parameters of the model      \n",
    "      b : (scalar)              value of bias parameter of the model\n",
    "    Returns\n",
    "      dj_dw : (ndarray Shape (n,)) The gradient of the cost w.r.t. the parameters w. \n",
    "      dj_db : (scalar)             The gradient of the cost w.r.t. the parameter b. \n",
    "    \"\"\"\n",
    "    m, n = X.shape\n",
    "    dj_dw = np.zeros(w.shape)\n",
    "    dj_db = 0.\n",
    "\n",
    "    ### START CODE HERE ### \n",
    "\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "\n",
    "        \n",
    "    return dj_db, dj_dw"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e1e0fb1",
   "metadata": {},
   "source": [
    " <details>\n",
    "  <summary><font size=\"3\" color=\"darkgreen\"><b>Hints</b></font></summary>\n",
    "    \n",
    "    \n",
    "* Here's how you can structure the overall implementation for this function\n",
    "    ```python \n",
    "       def find_gradient(X, y, w, b): \n",
    "            m, n = X.shape\n",
    "            dj_dw = np.zeros(w.shape)\n",
    "            dj_db = 0.\n",
    "        \n",
    "            ### START CODE HERE ### \n",
    "            for i in range(m):\n",
    "                # Calculate f_wb (exactly as you did in the cost function above)\n",
    "                f_wb = \n",
    "        \n",
    "                # Calculate the  gradient for b from this example\n",
    "                dj_db_i = # Your code here to calculate the error\n",
    "        \n",
    "                # add that to dj_db\n",
    "                dj_db += dj_db_i\n",
    "        \n",
    "                # get dj_dw for each attribute\n",
    "                for j in range(n):\n",
    "                    # You code here to calculate the gradient from the i-th example for j-th attribute\n",
    "                    dj_dw_ij =  \n",
    "                    dj_dw[j] += dj_dw_ij\n",
    "        \n",
    "            # divide dj_db and dj_dw by total number of examples\n",
    "            dj_dw = dj_dw / m\n",
    "            dj_db = dj_db / m\n",
    "            ### END CODE HERE ###\n",
    "       \n",
    "            return dj_db, dj_dw\n",
    "    ```\n",
    "\n",
    "    * If you are new to Python, please check that your code is properly indented with consistent spaces or tabs. Otherwise, it might produce a different output or raise an `IndentationError: unexpected indent` error.\n",
    "    * If you're still stuck, you can check the hints presented below to figure out how to calculate `f_wb`, `dj_db_i` and `dj_dw_ij` \n",
    "    \n",
    "    <details>\n",
    "          <summary><font size=\"2\" color=\"darkblue\"><b>Hint to calculate f_wb</b></font></summary>\n",
    "           &emsp; &emsp; Recall that you calculated f_wb in <code>compute_cost</code> above — for detailed hints on how to calculate each intermediate term, check out the hints section below that exercise\n",
    "           <details>\n",
    "              <summary><font size=\"2\" color=\"darkorange\"><b>&emsp; &emsp; More hints to calculate f_wb</b></font></summary>\n",
    "              &emsp; &emsp; You can calculate f_wb as\n",
    "               \n",
    "    ```python \n",
    "               for i in range(m):   \n",
    "                   # Calculate f_wb (exactly how you did it in the compute_cost function above)\n",
    "                   z_wb = 0\n",
    "                   # Loop over each feature\n",
    "                   for j in range(n): \n",
    "                       # Add the corresponding term to z_wb\n",
    "                       z_wb+= X[i,j]*w[j]\n",
    "            \n",
    "                   # Add bias term \n",
    "                   z_wb += b\n",
    "        \n",
    "                   # Calculate the prediction from the model\n",
    "                   f_wb = sigmoid(z_wb)\n",
    "    ```\n",
    "               \n",
    "    </details>\n",
    "        \n",
    "    </details>\n",
    "    <details>\n",
    "          <summary><font size=\"2\" color=\"darkblue\"><b>Hint to calculate dj_db_i</b></font></summary>\n",
    "           &emsp; &emsp; You can calculate dj_db_i as <code>dj_db_i = f_wb - y[i]</code>\n",
    "    </details>\n",
    "        \n",
    "    <details>\n",
    "          <summary><font size=\"2\" color=\"darkblue\"><b>Hint to calculate dj_dw_ij</b></font></summary>\n",
    "        &emsp; &emsp; You can calculate dj_dw_ij as <code>dj_dw_ij = (f_wb - y[i])* X[i][j]</code>\n",
    "    </details>\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bfba76d",
   "metadata": {},
   "source": [
    "Run the cells below to check your implementation of the `find_gradient` function with two different initializations of the parameters **w** and **b**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "abf483e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dj_db at initial w and b (zeros):-0.043209876543209874\n",
      "dj_dw at initial w and b (zeros):[-8.181141350193935, -7.646521347385949]\n"
     ]
    }
   ],
   "source": [
    "# Compute and display gradient with w and b initialized to zeros\n",
    "initial_w = np.zeros(n)\n",
    "initial_b = 0.\n",
    "\n",
    "dj_db, dj_dw = find_gradient(x_train, y_train, initial_w, initial_b)\n",
    "print(f'dj_db at initial w and b (zeros):{dj_db}' )\n",
    "print(f'dj_dw at initial w and b (zeros):{dj_dw.tolist()}' )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84861ee8",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "<table>\n",
    "  <tr>\n",
    "    <td> <b>dj_db at initial w and b (zeros)<b></td>\n",
    "    <td> -0.043209876543209874 </td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td> <b>dj_dw at initial w and b (zeros):<b></td>\n",
    "    <td> [-8.181141350193935, -7.646521347385949] </td> \n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e0de7354",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dj_db at test w and b: -0.5432098765421223\n",
      "dj_dw at test w and b: [-40.20655954313042, -40.10329811602522]\n"
     ]
    }
   ],
   "source": [
    "# Compute and display cost and gradient with non-zero w and b\n",
    "test_w = np.array([ 0.2, -0.5])\n",
    "test_b = -24\n",
    "dj_db, dj_dw  = find_gradient(x_train, y_train, test_w, test_b)\n",
    "\n",
    "print('dj_db at test w and b:', dj_db)\n",
    "print('dj_dw at test w and b:', dj_dw.tolist())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f655176d",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "<table>\n",
    "  <tr>\n",
    "    <td> <b>dj_db at test w and b (non-zeros)<b></td>\n",
    "    <td> -0.5432098765421223 </td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td> <b>dj_dw at test w and b (non-zeros):<b></td>\n",
    "    <td>  [-40.20655954313042, -40.10329811602522] </td> \n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e48c94c5",
   "metadata": {},
   "source": [
    "<a name=\"2.6\"></a>\n",
    "### 2.6 Learning parameters using gradient descent \n",
    "\n",
    "Similar to the previous assignment, you will now find the optimal parameters of a logistic regression model by using gradient descent. \n",
    "- You don't need to implement anything for this part. Simply run the cells below. \n",
    "\n",
    "- A good way to verify that gradient descent is working correctly is to look\n",
    "at the value of $J(\\mathbf{w},b)$ and check that it is decreasing with each step. \n",
    "\n",
    "- Assuming you have implemented the gradient and computed the cost correctly, your value of $J(\\mathbf{w},b)$ should never increase, and should converge to a steady value by the end of the algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "23bec160",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_descent(X, y, w_in, b_in, cost_function, gradient_function, alpha, num_iters, lambda_): \n",
    "    \"\"\"\n",
    "    Args:\n",
    "      X :    (ndarray Shape (m, n) data, m examples by n features\n",
    "      y :    (ndarray Shape (m,))  target value \n",
    "      w_in : (ndarray Shape (n,))  Initial values of parameters of the model\n",
    "      b_in : (scalar)              Initial value of parameter of the model\n",
    "      cost_function :              function to compute cost(you already completed)\n",
    "      gradient_function :          function to find gradient(function you have just completed)\n",
    "      alpha : (float)              Learning rate\n",
    "      num_iters : (int)            number of iterations to run gradient descent\n",
    "      lambda_ : (scalar, float)    regularization constant\n",
    "      \n",
    "    Returns:\n",
    "      w : (ndarray Shape (n,)) Updated values of parameters of the model after\n",
    "          running gradient descent\n",
    "      b : (scalar)                Updated value of parameter of the model after\n",
    "          running gradient descent\n",
    "    \"\"\"\n",
    "    \n",
    "    # number of training examples\n",
    "    m = len(X)\n",
    "    \n",
    "    # An array to store cost J and w's at each iteration primarily for graphing later\n",
    "    J_history = []\n",
    "    w_history = []\n",
    "    \n",
    "    for i in range(num_iters):\n",
    "\n",
    "        # Calculate the gradient and update the parameters\n",
    "        dj_db, dj_dw = gradient_function(X, y, w_in, b_in)   \n",
    "\n",
    "        # Update Parameters using w, b, alpha and gradient\n",
    "        w_in = w_in - alpha * dj_dw               \n",
    "        b_in = b_in - alpha * dj_db              \n",
    "       \n",
    "        # Save cost J at each iteration\n",
    "        if i<10000:      # prevent resource exhaustion \n",
    "            cost =  cost_function(X, y, w_in, b_in)\n",
    "            J_history.append(cost)\n",
    "\n",
    "        # Print cost every at intervals 10 times or as many iterations if < 10\n",
    "        if i% math.ceil(num_iters/10) == 0 or i == (num_iters-1):\n",
    "            w_history.append(w_in)\n",
    "            print(f\"Iteration {i:4}: Cost {float(J_history[-1]):8.2f}   \")\n",
    "        \n",
    "    return w_in, b_in, J_history, w_history #return w and J,w history for graphing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fac01f91",
   "metadata": {},
   "source": [
    "Now let's run the gradient descent algorithm above to learn the parameters for our dataset.\n",
    "\n",
    "**Note:** The code block below takes a couple of minutes to run. You can reduce the iterations to test your implementation and iterate faster. If you have time later, try running with high values of iterations for better results.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "8f93d0fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration    0: Cost     1.17   \n",
      "Iteration 1000: Cost     0.31   \n",
      "Iteration 2000: Cost     0.31   \n",
      "Iteration 3000: Cost     0.31   \n",
      "Iteration 4000: Cost     0.31   \n",
      "Iteration 5000: Cost     0.31   \n",
      "Iteration 6000: Cost     0.31   \n",
      "Iteration 7000: Cost     0.31   \n",
      "Iteration 8000: Cost     0.31   \n",
      "Iteration 9000: Cost     0.31   \n",
      "Iteration 9999: Cost     0.31   \n"
     ]
    }
   ],
   "source": [
    "np.random.seed(1)\n",
    "initial_w = 0.01 * (np.random.rand(2) - 0.5)\n",
    "initial_b = -8\n",
    "\n",
    "# Some gradient descent settings\n",
    "iterations = 10000\n",
    "alpha = 0.001\n",
    "\n",
    "w,b, J_history,_ = gradient_descent(x_train ,y_train, initial_w, initial_b, \n",
    "                                   cost, find_gradient, alpha, iterations, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "644221bd",
   "metadata": {},
   "source": [
    "<a name=\"2.7\"></a>\n",
    "### 2.7 Plotting the decision boundary\n",
    "\n",
    "We will now use the final parameters from gradient descent to plot the linear fit. If you implemented the previous parts correctly, you should see a plot similar to the following plot:   \n",
    "\n",
    "We will use a helper function in the `labbuddy.py` file to create this plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "502c47a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_decision_boundary(w, b, x_train, y_train,\"sub1\",\"sub2\",\"Admitted\",\"Not Admitted\",True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c900229",
   "metadata": {},
   "source": [
    "<a name=\"2.8\"></a>\n",
    "### 2.8 Evaluating logistic regression\n",
    "\n",
    "We can evaluate the quality of the parameters we have found by seeing how well the learned model predicts on our training set. \n",
    "\n",
    "You will implement the `predict` function below to do this."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51c6282f",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "\n",
    "Please complete the `predict` function to produce `1` or `0` predictions given a dataset and a learned parameter vector $w$ and $b$.\n",
    "- First you need to compute the prediction from the model $f(x^{(i)}) = g(w \\cdot x^{(i)} + b)$ for every example \n",
    "    - You've implemented this before in the parts above\n",
    "- We interpret the output of the model ($f(x^{(i)})$) as the probability that $y^{(i)}=1$ given $x^{(i)}$ and parameterized by $w$.\n",
    "- Therefore, to get a final prediction ($y^{(i)}=0$ or $y^{(i)}=1$) from the logistic regression model, you can use the following heuristic -\n",
    "\n",
    "  if $f(x^{(i)}) >= 0.5$, predict $y^{(i)}=1$\n",
    "  \n",
    "  if $f(x^{(i)}) < 0.5$, predict $y^{(i)}=0$\n",
    "    \n",
    "If you get stuck, you can check out the hints presented after the cell below to help you with the implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "e2929cba",
   "metadata": {},
   "outputs": [],
   "source": [
    "# UNQ_C4\n",
    "# GRADED FUNCTION: predict\n",
    "\n",
    "def predict(X, w, b): \n",
    "    \"\"\"\n",
    "    Predict whether the label is 0 or 1 using learned logistic\n",
    "    regression parameters w\n",
    "    \n",
    "    Args:\n",
    "      X : (ndarray Shape (m,n)) data, m examples by n features\n",
    "      w : (ndarray Shape (n,))  values of parameters of the model      \n",
    "      b : (scalar)              value of bias parameter of the model\n",
    "\n",
    "    Returns:\n",
    "      p : (ndarray (m,)) The predictions for X using a threshold at 0.5\n",
    "    \"\"\"\n",
    "    # number of training examples\n",
    "    m, n = X.shape   \n",
    "    p = np.zeros(m)\n",
    "   \n",
    "    ### START CODE HERE ### \n",
    "    # Loop over each example\n",
    "\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    ### END CODE HERE ### \n",
    "    return p"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9c15032",
   "metadata": {},
   "source": [
    "<details>\n",
    "  <summary><font size=\"3\" color=\"darkgreen\"><b>Hints</b></font></summary>\n",
    "    \n",
    "    \n",
    "* Here's how you can structure the overall implementation for this function\n",
    "    ```python \n",
    "       def predict(X, w, b): \n",
    "            # number of training examples\n",
    "            m, n = X.shape   \n",
    "            p = np.zeros(m)\n",
    "   \n",
    "            ### START CODE HERE ### \n",
    "            # Loop over each example\n",
    "            for i in range(m):   \n",
    "                \n",
    "                # Calculate f_wb (exactly how you did it in the compute_cost function above) \n",
    "                # using a couple of lines of code\n",
    "                f_wb = \n",
    "\n",
    "                # Calculate the prediction for that training example \n",
    "                p[i] = # Your code here to calculate the prediction based on f_wb\n",
    "        \n",
    "            ### END CODE HERE ### \n",
    "            return p\n",
    "    ```\n",
    "  \n",
    "    If you're still stuck, you can check the hints presented below to figure out how to calculate `f_wb` and `p[i]` \n",
    "    \n",
    "    <details>\n",
    "          <summary><font size=\"2\" color=\"darkblue\"><b>Hint to calculate f_wb</b></font></summary>\n",
    "           &emsp; &emsp; Recall that you calculated f_wb in <code>compute_cost</code> above — for detailed hints on how to calculate each intermediate term, check out the hints section below that exercise\n",
    "           <details>\n",
    "              <summary><font size=\"2\" color=\"darkorange\"><b>&emsp; &emsp; More hints to calculate f_wb</b></font></summary>\n",
    "              &emsp; &emsp; You can calculate f_wb as\n",
    "               \n",
    "    ```python \n",
    "               for i in range(m):   \n",
    "                   # Calculate f_wb (exactly how you did it in the compute_cost function above)\n",
    "                   z_wb = 0\n",
    "                   # Loop over each feature\n",
    "                   for j in range(n): \n",
    "                       # Add the corresponding term to z_wb\n",
    "                       z_wb_ij = X[i, j] * w[j]\n",
    "                       z_wb += z_wb_ij\n",
    "            \n",
    "                   # Add bias term \n",
    "                   z_wb += b\n",
    "        \n",
    "                   # Calculate the prediction from the model\n",
    "                   f_wb = sigmoid(z_wb)\n",
    "    ```\n",
    "    </details>\n",
    "        \n",
    "    </details>\n",
    "    <details>\n",
    "          <summary><font size=\"2\" color=\"darkblue\"><b>Hint to calculate p[i]</b></font></summary>\n",
    "           &emsp; &emsp; As an example, if you'd like to say x = 1 if y is less than 3 and 0 otherwise, you can express it in code as <code>x = y < 3 </code>. Now do the same for p[i] = 1 if f_wb >= 0.5 and 0 otherwise. \n",
    "           <details>\n",
    "              <summary><font size=\"2\" color=\"darkorange\"><b>&emsp; &emsp; More hints to calculate p[i]</b></font></summary>\n",
    "              &emsp; &emsp; You can compute p[i] as <code>p[i] = f_wb >= 0.5</code>\n",
    "          </details>\n",
    "    </details>\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b30fc7e7",
   "metadata": {},
   "source": [
    "Once you have completed the function `predict`, let's run the code below to report the training accuracy of your classifier by computing the percentage of examples it got correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9c78df49",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy: 85.000000\n"
     ]
    }
   ],
   "source": [
    "#Compute accuracy on our training set\n",
    "p = predict(x_test, w,b)\n",
    "print('Train Accuracy: %f'%(np.mean(p == y_test) * 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a50cec3a",
   "metadata": {},
   "source": [
    "# Congratulation! <img align=\"left\"  src=\"data:image/jpeg;base64,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\" style=\" width:40px;  \">\n",
    "Did you realise! You have made a logistic Regression Model by yourself it is really a great achivement.\n",
    "Team SAE appreciates your patience and dedication in this `Great Journey` and `Thank You` for be with us in this workshop "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19adec79",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}