C1_W3_Exercise2_Logistic_Regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "acae739b",
   "metadata": {},
   "source": [
    "## Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "057a30ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import package\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from utils import *\n",
    "import copy \n",
    "import math\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c10883ad",
   "metadata": {},
   "source": [
    "## 2 - Logistic Regression\n",
    "\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",
    "### 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",
    "### 2.2 Loading and visualizing the data\n",
    "\n",
    "You will start by loading the dataset for this task. \n",
    "- The `load_dataset()` function shown below 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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "839a64de",
   "metadata": {},
   "outputs": [],
   "source": [
    "# load dataset\n",
    "x_train, y_train = load_data(\"data/ex2data1.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "838d9671",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First five elements in x_train are:  [[34.62365962 78.02469282]\n",
      " [30.28671077 43.89499752]\n",
      " [35.84740877 72.90219803]\n",
      " [60.18259939 86.3085521 ]\n",
      " [79.03273605 75.34437644]]\n",
      "Type of x_train:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(\"First five elements in x_train are: \",x_train[:5])\n",
    "print(\"Type of x_train: \", type(x_train))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f67e806f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First five elements in y_train are:  [0. 0. 0. 1. 1.]\n",
      "Type of y_train:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(\"First five elements in y_train are: \", y_train[:5])\n",
    "print(\"Type of y_train: \", type(y_train))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d8dc8c3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shape of x_train are: (100, 2)\n",
      "The shape of y_train are: (100,)\n",
      "we have m = 100 training examples\n"
     ]
    }
   ],
   "source": [
    "# checking the dimensions\n",
    "\n",
    "print(\"The shape of x_train are: \" + str(x_train.shape))\n",
    "print(\"The shape of y_train are: \" + str(y_train.shape))\n",
    "print('we have m = %d training examples' % (len(y_train)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "185f6010",
   "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",
    "- We use a helper function in the ``utils.py`` file to generate this plot. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f8f4623e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot example\n",
    "\n",
    "plot_data(x_train, y_train[:], pos_label = \"Admitted\", neg_label = \"Not Admitted\")\n",
    "\n",
    "# Set the y-axis label\n",
    "plt.ylabel(\"Exam 2 score\")\n",
    "# Set the x-axis label\n",
    "plt.xlabel(\"Exam 1 score\")\n",
    "plt.legend(loc = \"upper right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e62a8f94",
   "metadata": {},
   "source": [
    "### 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",
    "### 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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2cfa4b78",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    g = 1/ (1 + np.exp(-z))\n",
    "    return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "42663e02",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigmoid(0) = 0.5\n",
      "sigmoid([-1, 0, 1, 2]) = [0.26894142 0.5        0.73105858 0.88079708]\n"
     ]
    }
   ],
   "source": [
    "value = 0\n",
    "print(f\"sigmoid({value}) = {sigmoid(value)}\")\n",
    "print(f\"sigmoid([-1, 0, 1, 2]) = {sigmoid(np.array([-1, 0, 1, 2]))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db615b4d",
   "metadata": {},
   "source": [
    "### 2.4 Cost function for logistic regression\n",
    "\n",
    "In this section, you will implement the cost function for logistic regression.\n",
    "\n",
    "### Exercise 2\n",
    "\n",
    "Please complete the `compute_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",
    "    * It might be helpful to first calculate an intermediate variable $z_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) = \\mathbf{w} \\cdot \\mathbf{x^{(i)}} + b = w_0x^{(i)}_0 + ... + w_{n-1}x^{(i)}_{n-1} + b$ where $n$ is the number of features, before calculating $f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) = g(z_{\\mathbf{w},b}(\\mathbf{x}^{(i)}))$\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "73374b56",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(x, y, w, b):\n",
    "    m = x.shape[0]\n",
    "    cost = 0.0\n",
    "    for i in range(m):\n",
    "        z_wb = np.dot(x[i],w) + b\n",
    "        f_wb_i = sigmoid(z_wb)\n",
    "        cost += -y[i]*np.log(f_wb_i) - (1 - y[i])*np.log(1 - f_wb_i)\n",
    "    cost /= m\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d0eb1c74",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost at initial w and b (zeros): 0.693\n"
     ]
    }
   ],
   "source": [
    "m, n = x_train.shape\n",
    "\n",
    "# Compute and display cost with w and b initialized to zeros\n",
    "initial_w = np.zeros(n)\n",
    "initial_b = 0.\n",
    "cost = compute_cost(x_train, y_train, initial_w, initial_b)\n",
    "print('Cost at initial w and b (zeros): {:.3f}'.format(cost))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0da9e124",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost at test w and b (non-zeros): 0.218\n"
     ]
    }
   ],
   "source": [
    "# Compute and display cost with non-zero w and b\n",
    "test_w = np.array([0.2, 0.2])\n",
    "test_b = -24.\n",
    "cost = compute_cost(x_train, y_train, test_w, test_b)\n",
    "\n",
    "print('Cost at test w and b (non-zeros): {:.3f}'.format(cost))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "565d3d38",
   "metadata": {},
   "source": [
    "### 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": "dae73f34",
   "metadata": {},
   "source": [
    "### Exercise 3\n",
    "\n",
    "Please complete the `compute_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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "467de4aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_gradient(x, y, w, b):\n",
    "    m,n = x.shape\n",
    "    dj_dw = np.zeros((n,))\n",
    "    dj_db = 0\n",
    "    for i in range(m):\n",
    "        f_wb = sigmoid(np.dot(x[i],w) + b)\n",
    "        err = f_wb - y[i]\n",
    "        for j in range(n):\n",
    "            dj_dw[j] += err*x[i][j]\n",
    "        dj_db += err\n",
    "    \n",
    "    dj_dw /= m\n",
    "    dj_db /= m\n",
    "    \n",
    "    return dj_dw, dj_db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "ec19000e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dj_db at initial w and b (zeros):-0.1\n",
      "dj_dw at initial w and b (zeros):[-12.00921658929115, -11.262842205513591]\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_dw, dj_db = compute_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": "code",
   "execution_count": 30,
   "id": "a16004c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dj_db at test w and b: -0.5999999999991071\n",
      "dj_dw at test w and b: [-44.831353617873795, -44.37384124953978]\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_dw, dj_db  = compute_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())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cca7510",
   "metadata": {},
   "source": [
    "### 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": 31,
   "id": "690743eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_descent(x, y, w_in, b_in, cost_function, gradient_function, alpha, num_iters):\n",
    "    m,n = x.shape\n",
    "    w = copy.deepcopy(w_in)\n",
    "    b = b_in\n",
    "    J_history = []\n",
    "    w_history = []\n",
    "    for i in range(num_iters):\n",
    "        dj_dw, dj_db = gradient_function(x, y, w, b)\n",
    "        \n",
    "        w = w - alpha*dj_dw\n",
    "        b = b - alpha*dj_db\n",
    "        \n",
    "        if i < 100000:\n",
    "            cost = cost_function(x, y, w, b)\n",
    "            J_history.append(cost)\n",
    "        \n",
    "        if i%math.ceil(num_iters/10) == 0 or i == (num_iters-1):\n",
    "            w_history.append(w)\n",
    "            print(f\"Iteration {i:4}: Cost {float(J_history[-1]):8.2f}   \")\n",
    "            \n",
    "    return w, b, J_history, w_history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "d6210b7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration    0: Cost     0.96   \n",
      "Iteration 1000: Cost     0.31   \n",
      "Iteration 2000: Cost     0.30   \n",
      "Iteration 3000: Cost     0.30   \n",
      "Iteration 4000: Cost     0.30   \n",
      "Iteration 5000: Cost     0.30   \n",
      "Iteration 6000: Cost     0.30   \n",
      "Iteration 7000: Cost     0.30   \n",
      "Iteration 8000: Cost     0.30   \n",
      "Iteration 9000: Cost     0.30   \n",
      "Iteration 9999: Cost     0.30   \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",
    "                                   compute_cost, compute_gradient, alpha, iterations)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab4cf840",
   "metadata": {},
   "source": [
    "### Plotting the decision boundary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "091b1ea2",
   "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)\n",
    "\n",
    "plt.ylabel(\"Exam 2 score\")\n",
    "plt.xlabel(\"Exam 1 score\")\n",
    "\n",
    "plt.legend(loc = \"upper right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89120acf",
   "metadata": {},
   "source": [
    "### 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.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36a13cc5",
   "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",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "6b1296a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(x, w, b):\n",
    "    m,n = x.shape\n",
    "    p = np.zeros(m)\n",
    "    \n",
    "    for i in range(m):\n",
    "        f_wb_i = sigmoid(np.dot(x[i],w) + b)\n",
    "        p[i] = f_wb_i>= 0.5\n",
    "    \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "0c1ef079",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output of predict: shape (4,), value [0. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "# Test your predict code\n",
    "np.random.seed(1)\n",
    "tmp_w = np.random.randn(2)\n",
    "tmp_b = 0.3    \n",
    "tmp_X = np.random.randn(4, 2) - 0.5\n",
    "\n",
    "tmp_p = predict(tmp_X, tmp_w, tmp_b)\n",
    "print(f'Output of predict: shape {tmp_p.shape}, value {tmp_p}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "52bf30cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy: 92.000000\n"
     ]
    }
   ],
   "source": [
    "#Compute accuracy on our training set\n",
    "p = predict(x_train, w,b)\n",
    "print('Train Accuracy: %f'%(np.mean(p == y_train) * 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8344312",
   "metadata": {},
   "source": [
    "## 3 - Regularized Logistic Regression\n",
    "\n",
    "In this part of the exercise, you will implement regularized logistic regression to predict whether microchips from a fabrication plant passes quality assurance (QA). During QA, each microchip goes through various tests to ensure it is functioning correctly. \n",
    "\n",
    "### 3.1 Problem Statement\n",
    "\n",
    "Suppose you are the product manager of the factory and you have the test results for some microchips on two different tests. \n",
    "- From these two tests, you would like to determine whether the microchips should be accepted or rejected. \n",
    "- To help you make the decision, you have a dataset of test results on past microchips, from which you can build a logistic regression model.\n",
    "\n",
    "### 3.2 Loading and visualizing the data\n",
    "\n",
    "Similar to previous parts of this exercise, let's start by loading the dataset for this task and visualizing it. \n",
    "\n",
    "- The `load_dataset()` function shown below loads the data into variables `X_train` and `y_train`\n",
    "  - `X_train` contains the test results for the microchips from two tests\n",
    "  - `y_train` contains the results of the QA  \n",
    "      - `y_train = 1` if the microchip was accepted \n",
    "      - `y_train = 0` if the microchip was rejected \n",
    "  - Both `X_train` and `y_train` are numpy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "23097389",
   "metadata": {},
   "outputs": [],
   "source": [
    "# load dataset\n",
    "x_train, y_train = load_data(\"data/ex2data2.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "226e9283",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train:  [[ 0.051267  0.69956 ]\n",
      " [-0.092742  0.68494 ]\n",
      " [-0.21371   0.69225 ]\n",
      " [-0.375     0.50219 ]\n",
      " [-0.51325   0.46564 ]]\n",
      "Type of x_train:  <class 'numpy.ndarray'>\n",
      "y_train:  [1. 1. 1. 1. 1.]\n",
      "Type of y_train:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(\"x_train: \", x_train[:5])\n",
    "print(\"Type of x_train: \", type(x_train))\n",
    "\n",
    "print(\"y_train: \", y_train[:5])\n",
    "print(\"Type of y_train: \", type(y_train))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "8c08de4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shape of X_train is: (118, 2)\n",
      "The shape of y_train is: (118,)\n",
      "We have m = 118 training examples\n"
     ]
    }
   ],
   "source": [
    "# checking the dimension\n",
    "\n",
    "print ('The shape of X_train is: ' + str(x_train.shape))\n",
    "print ('The shape of y_train is: ' + str(y_train.shape))\n",
    "print ('We have m = %d training examples' % (len(y_train)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f62e799d",
   "metadata": {},
   "source": [
    "### visualizing our data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "b396eb32",
   "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[:], pos_label = \"Accepted\", neg_label = \"Rejected\")\n",
    "plt.ylabel('Microchip Test 2')\n",
    "plt.xlabel('Microchip Test 1')\n",
    "plt.legend(loc = \"upper right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55dc1cdd",
   "metadata": {},
   "source": [
    "### 3.3 Feature mapping\n",
    "\n",
    "One way to fit the data better is to create more features from each data point. In the provided function `map_feature`, we will map the features into all polynomial terms of $x_1$ and $x_2$ up to the sixth power.\n",
    "\n",
    "$$\\mathrm{map\\_feature}(x) = \n",
    "\\left[\\begin{array}{c}\n",
    "x_1\\\\\n",
    "x_2\\\\\n",
    "x_1^2\\\\\n",
    "x_1 x_2\\\\\n",
    "x_2^2\\\\\n",
    "x_1^3\\\\\n",
    "\\vdots\\\\\n",
    "x_1 x_2^5\\\\\n",
    "x_2^6\\end{array}\\right]$$\n",
    "\n",
    "As a result of this mapping, our vector of two features (the scores on two QA tests) has been transformed into a 27-dimensional vector. \n",
    "\n",
    "- A logistic regression classifier trained on this higher-dimension feature vector will have a more complex decision boundary and will be nonlinear when drawn in our 2-dimensional plot. \n",
    "- We have provided the `map_feature` function for you in utils.py. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "f419445f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original shape of data:  (118, 2)\n",
      "Shape after feature mapping: (118, 27)\n"
     ]
    }
   ],
   "source": [
    "print(\"Original shape of data: \", x_train.shape)\n",
    "\n",
    "mapped_x = map_feature(x_train[:, 0], x_train[:, 1])\n",
    "print(\"Shape after feature mapping:\", mapped_x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "ac308624",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train[0]: [0.051267 0.69956 ]\n",
      "mapped x_train[0]: [5.12670000e-02 6.99560000e-01 2.62830529e-03 3.58643425e-02\n",
      " 4.89384194e-01 1.34745327e-04 1.83865725e-03 2.50892595e-02\n",
      " 3.42353606e-01 6.90798869e-06 9.42624411e-05 1.28625106e-03\n",
      " 1.75514423e-02 2.39496889e-01 3.54151856e-07 4.83255257e-06\n",
      " 6.59422333e-05 8.99809795e-04 1.22782870e-02 1.67542444e-01\n",
      " 1.81563032e-08 2.47750473e-07 3.38066048e-06 4.61305487e-05\n",
      " 6.29470940e-04 8.58939846e-03 1.17205992e-01]\n"
     ]
    }
   ],
   "source": [
    "print(\"x_train[0]:\", x_train[0])\n",
    "print(\"mapped x_train[0]:\", mapped_x[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71eaf5dd",
   "metadata": {},
   "source": [
    "While the feature mapping allows us to build a more expressive classifier, it is also more susceptible to overfitting. In the next parts of the exercise, you will implement regularized logistic regression to fit the data and also see for yourself how regularization can help combat the overfitting problem.\n",
    "\n",
    "### 3.4 Cost function for regularized logistic regression\n",
    "\n",
    "In this part, you will implement the cost function for regularized logistic regression.\n",
    "\n",
    "Recall that for regularized logistic regression, the cost function is of the form\n",
    "$$J(\\mathbf{w},b) = \\frac{1}{m}  \\sum_{i=0}^{m-1} \\left[ -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) \\right] + \\frac{\\lambda}{2m}  \\sum_{j=0}^{n-1} w_j^2$$\n",
    "\n",
    "Compare this to the cost function without regularization (which you implemented above), which is of the form \n",
    "\n",
    "$$ J(\\mathbf{w}.b) = \\frac{1}{m}\\sum_{i=0}^{m-1} \\left[ (-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)\\right]$$\n",
    "\n",
    "The difference is the regularization term, which is $$\\frac{\\lambda}{2m}  \\sum_{j=0}^{n-1} w_j^2$$ \n",
    "Note that the $b$ parameter is not regularized."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca2153e8",
   "metadata": {},
   "source": [
    "### Exercise 5\n",
    "\n",
    "Please complete the `compute_cost_reg` function below to calculate the following term for each element in $w$ \n",
    "$$\\frac{\\lambda}{2m}  \\sum_{j=0}^{n-1} w_j^2$$\n",
    "\n",
    "The starter code then adds this to the cost without regularization (which you computed above in `compute_cost`) to calculate the cost with regulatization.\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": 51,
   "id": "bf7fa3f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost_reg(x, y, w, b, lambda_):\n",
    "    m,n = x.shape\n",
    "    \n",
    "    cost = compute_cost(x,y,w,b)\n",
    "    \n",
    "    reg_cost = 0\n",
    "    for j in range(n):\n",
    "        reg_cost += (lambda_/(2*m))*(w[j]**2)\n",
    "    \n",
    "    total_cost = cost + reg_cost\n",
    "    \n",
    "    return total_cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "d75dc044",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Regularized cost : 0.6618252552483948\n"
     ]
    }
   ],
   "source": [
    "X_mapped = map_feature(x_train[:, 0], x_train[:, 1])\n",
    "np.random.seed(1)\n",
    "initial_w = np.random.rand(X_mapped.shape[1]) - 0.5\n",
    "initial_b = 0.5\n",
    "lambda_ = 0.5\n",
    "cost = compute_cost_reg(X_mapped, y_train, initial_w, initial_b, lambda_)\n",
    "\n",
    "print(\"Regularized cost :\", cost)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2916317",
   "metadata": {},
   "source": [
    "### 3.5 Gradient for regularized logistic regression\n",
    "\n",
    "In this section, you will implement the gradient for regularized logistic regression.\n",
    "\n",
    "\n",
    "The gradient of the regularized cost function has two components. The first, $\\frac{\\partial J(\\mathbf{w},b)}{\\partial b}$ is a scalar, the other is a vector with the same shape as the parameters $\\mathbf{w}$, where the $j^\\mathrm{th}$ element is defined as follows:\n",
    "\n",
    "$$\\frac{\\partial J(\\mathbf{w},b)}{\\partial b} = \\frac{1}{m}  \\sum_{i=0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - y^{(i)})  $$\n",
    "\n",
    "$$\\frac{\\partial J(\\mathbf{w},b)}{\\partial w_j} = \\left( \\frac{1}{m}  \\sum_{i=0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - y^{(i)}) x_j^{(i)} \\right) + \\frac{\\lambda}{m} w_j  \\quad\\, \\mbox{for $j=0...(n-1)$}$$\n",
    "\n",
    "Compare this to the gradient of the cost function without regularization (which you implemented above), which is of the form \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",
    "\n",
    "\n",
    "As you can see,$\\frac{\\partial J(\\mathbf{w},b)}{\\partial b}$ is the same, the difference is the following term in $\\frac{\\partial J(\\mathbf{w},b)}{\\partial w}$, which is $$\\frac{\\lambda}{m} w_j  \\quad\\, \\mbox{for $j=0...(n-1)$}$$ \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f4cff1b",
   "metadata": {},
   "source": [
    "### Exercise 6\n",
    "\n",
    "Please complete the `compute_gradient_reg` function below to modify the code below to calculate the following term\n",
    "\n",
    "$$\\frac{\\lambda}{m} w_j  \\quad\\, \\mbox{for $j=0...(n-1)$}$$\n",
    "\n",
    "The starter code will add this term to the $\\frac{\\partial J(\\mathbf{w},b)}{\\partial w}$ returned from `compute_gradient` above to get the gradient for the regularized cost function.\n",
    "\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": 53,
   "id": "2e84cd64",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_gradient_reg(x, y, w, b, lambda_):\n",
    "    dj_dw, dj_db = compute_gradient(x, y, w, b)\n",
    "    m,n = x.shape\n",
    "    \n",
    "    for j in range(n):\n",
    "        dj_dw[j] += (lambda_/m)*w[j]\n",
    "    \n",
    "    return dj_dw, dj_db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "1e8e6cb1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dj_db: 0.07138288792343662\n",
      "First few elements of regularized dj_dw:\n",
      " [-0.010386028450548701, 0.011409852883280122, 0.0536273463274574, 0.0031402782673134655]\n"
     ]
    }
   ],
   "source": [
    "X_mapped = map_feature(x_train[:, 0], x_train[:, 1])\n",
    "np.random.seed(1) \n",
    "initial_w  = np.random.rand(X_mapped.shape[1]) - 0.5 \n",
    "initial_b = 0.5\n",
    " \n",
    "lambda_ = 0.5\n",
    "dj_dw, dj_db = compute_gradient_reg(X_mapped, y_train, initial_w, initial_b, lambda_)\n",
    "\n",
    "print(f\"dj_db: {dj_db}\", )\n",
    "print(f\"First few elements of regularized dj_dw:\\n {dj_dw[:4].tolist()}\", )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "991205b3",
   "metadata": {},
   "source": [
    "### 3.6 Learning parameters using gradient descent\n",
    "\n",
    "Similar to the previous parts, you will use your gradient descent function implemented above to learn the optimal parameters $w$,$b$. \n",
    "- If you have completed the cost and gradient for regularized logistic regression correctly, you should be able to step through the next cell to learn the parameters $w$. \n",
    "- After training our parameters, we will use it to plot the decision boundary. \n",
    "\n",
    "**Note**\n",
    "\n",
    "The code block below takes quite a while to run, especially with a non-vectorized version. You can reduce the `iterations` to test your implementation and iterate faster. If you have time later, run for 100,000 iterations to see better results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "9c193266",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_descent_reg(x, y, w_in, b_in, cost_function, gradient_function, alpha, num_iters, lambda_):\n",
    "    m,n = x.shape\n",
    "    w = copy.deepcopy(w_in)\n",
    "    b = b_in\n",
    "    J_history = []\n",
    "    w_history = []\n",
    "    for i in range(num_iters):\n",
    "        dj_dw, dj_db = gradient_function(x, y, w, b, lambda_)\n",
    "        \n",
    "        w = w - alpha*dj_dw\n",
    "        b = b - alpha*dj_db\n",
    "        \n",
    "        if i < 100000:\n",
    "            cost = cost_function(x, y, w, b, lambda_)\n",
    "            J_history.append(cost)\n",
    "        \n",
    "        if i%math.ceil(num_iters/10) == 0 or i == (num_iters-1):\n",
    "            w_history.append(w)\n",
    "            print(f\"Iteration {i:4}: Cost {float(J_history[-1]):8.2f}   \")\n",
    "            \n",
    "    return w, b, J_history, w_history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "55e22db4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration    0: Cost     0.72   \n",
      "Iteration 1000: Cost     0.59   \n",
      "Iteration 2000: Cost     0.56   \n",
      "Iteration 3000: Cost     0.53   \n",
      "Iteration 4000: Cost     0.51   \n",
      "Iteration 5000: Cost     0.50   \n",
      "Iteration 6000: Cost     0.48   \n",
      "Iteration 7000: Cost     0.47   \n",
      "Iteration 8000: Cost     0.46   \n",
      "Iteration 9000: Cost     0.45   \n",
      "Iteration 9999: Cost     0.45   \n"
     ]
    }
   ],
   "source": [
    "# Initialize fitting parameters\n",
    "np.random.seed(1)\n",
    "initial_w = np.random.rand(X_mapped.shape[1])-0.5\n",
    "initial_b = 1.\n",
    "\n",
    "# Set regularization parameter lambda_ (you can try varying this)\n",
    "lambda_ = 0.01    \n",
    "\n",
    "# Some gradient descent settings\n",
    "iterations = 10000\n",
    "alpha = 0.01\n",
    "\n",
    "w,b, J_history,_ = gradient_descent_reg(X_mapped, y_train, initial_w, initial_b, \n",
    "                                    compute_cost_reg, compute_gradient_reg, \n",
    "                                    alpha, iterations, lambda_)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abd863b0",
   "metadata": {},
   "source": [
    "### Plotting the Decision Boundary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "44e4f3b5",
   "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_mapped, y_train)\n",
    "plt.ylabel('Microchip Test 2')\n",
    "plt.xlabel('Microchip Test 1')\n",
    "plt.legend(loc = \"upper right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "ceef7057",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy: 82.203390\n"
     ]
    }
   ],
   "source": [
    "#Compute accuracy on the training set\n",
    "p = predict(X_mapped, w, b)\n",
    "\n",
    "print('Train Accuracy: %f'%(np.mean(p == y_train) * 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29e375b8",
   "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.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}