assignment_logistic_regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wNEUsAHHCGk2"
   },
   "source": [
    "##ASSIGNMENT\n",
    "#Dataset\n",
    "Assume you are a scientist who is trying to make a propellent and is trying many tests to make an efficient propellent .\n",
    "<br>\n",
    "You have performed two tests.\n",
    "<br>\n",
    "From the two tests you would like whether this propellent works efficiently or not.\n",
    "Build your own logistic regression model to decide .\n",
    "<br>\n",
    "Text with \"DO NOT EDIT THIS CODE\" needs to be only run do not edit it\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "xJm_XXJo4RDg"
   },
   "outputs": [],
   "source": [
    "#import libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "YtL0jW6m4e1A"
   },
   "outputs": [],
   "source": [
    "#load data\n",
    "data=np.loadtxt(\"data.txt\", delimiter=',')\n",
    "X=data[:,:2]\n",
    "y=data[:,2]\n",
    "X_train=X\n",
    "y_train=y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "Bk2qYHyk4mNm"
   },
   "outputs": [],
   "source": [
    "#plot data to visualise\n",
    "def plot_data(X,y,positive_label=\"y=1\", negative_label=\"y=0\"):\n",
    "#positive_label and negative_label refers to classes of y as y can be 0 or 1\n",
    "    positive = y == 1\n",
    "    negative = y == 0\n",
    "    plt.plot(X[positive, 0], X[positive, 1], 'k+', label=positive_label)\n",
    "    plt.plot(X[negative, 0], X[negative, 1], 'yo', label=negative_label)\n",
    "#While plotting graph the label parameter will be either positive_label or negative_label so plot both the labels for\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "RzsMdrwv58tQ"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#test\n",
    "plot_data(X_train, y_train[:], positive_label=\"Accepted\", negative_label=\"Rejected\")\n",
    "\n",
    "\n",
    "plt.xlabel('Test 2')\n",
    "plt.ylabel('Test 1')\n",
    "plt.legend(loc=\"upper right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "KhRBdaFi6nKo"
   },
   "outputs": [],
   "source": [
    "#feature mapping\n",
    "def map_feature(X1,X2):\n",
    "  X1=np.atleast_1d(X1)\n",
    "  X2=np.atleast_1d(X2)\n",
    "  degree=6\n",
    "  out=[]\n",
    "  for i in range(1,degree+1):\n",
    "    for j in range(i+1):\n",
    "      out.append((X1**(i-j) * (X2**j)))\n",
    "  return np.stack(out, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "PNS4kJfq6_m8"
   },
   "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": 12,
   "metadata": {
    "cellView": "form",
    "id": "BqlxZOXoHh4z"
   },
   "outputs": [],
   "source": [
    "# @title DO NOT EDIT THIS CODE\n",
    "def sigmoid_test(target):\n",
    "    assert np.isclose(target(3.0), 0.9525741268224334), \"Failed for scalar input\"\n",
    "    assert np.allclose(target(np.array([2.5, 0])), [0.92414182, 0.5]), \"Failed for 1D array\"\n",
    "    assert np.allclose(target(np.array([[2.5, -2.5], [0, 1]])),\n",
    "                       [[0.92414182, 0.07585818], [0.5, 0.73105858]]), \"Failed for 2D array\"\n",
    "    print('\\033[92mTests passed!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "wdgE-ay07C0P"
   },
   "outputs": [],
   "source": [
    "#sigmoid function\n",
    "def sigmoid(z):\n",
    "#write your code\n",
    "    return 1 / (1 + np.exp(-z))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "9XOlXXyxHnmB"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[92mTests passed!\n"
     ]
    }
   ],
   "source": [
    "sigmoid_test(sigmoid)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "cellView": "form",
    "id": "QLqfyxPrH-v-"
   },
   "outputs": [],
   "source": [
    "# @title DO NOT EDIT THIS CODE\n",
    "def compute_cost_test(target):\n",
    "    X = np.array([[0, 0, 0, 0]]).T\n",
    "    y = np.array([0, 0, 0, 0])\n",
    "    w = np.array([0])\n",
    "    b = 1\n",
    "    result = target(X, y, w, b)\n",
    "    if math.isinf(result):\n",
    "        raise ValueError(\"Did you get the sigmoid of z_wb?\")\n",
    "\n",
    "    np.random.seed(17)\n",
    "    X = np.random.randn(5, 2)\n",
    "    y = np.array([1, 0, 0, 1, 1])\n",
    "    w = np.random.randn(2)\n",
    "    b = 0\n",
    "    result = target(X, y, w, b)\n",
    "    assert np.isclose(result, 2.15510667), f\"Wrong output. Expected: {2.15510667} got: {result}\"\n",
    "\n",
    "    X = np.random.randn(4, 3)\n",
    "    y = np.array([1, 1, 0, 0])\n",
    "    w = np.random.randn(3)\n",
    "    b = 0\n",
    "\n",
    "    result = target(X, y, w, b)\n",
    "    assert np.isclose(result, 0.80709376), f\"Wrong output. Expected: {0.80709376} got: {result}\"\n",
    "\n",
    "    X = np.random.randn(4, 3)\n",
    "    y = np.array([1, 0,1, 0])\n",
    "    w = np.random.randn(3)\n",
    "    b = 3\n",
    "    result = target(X, y, w, b)\n",
    "    assert np.isclose(result, 0.4529660647), f\"Wrong output. Expected: {0.4529660647} got: {result}. Did you inizialized z_wb = b?\"\n",
    "\n",
    "    print('\\033[92mTests passed!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "PRIqcpJ17MzH"
   },
   "outputs": [],
   "source": [
    "#computing cost\n",
    "def compute_cost(X,y,w,b,lambda_=1):\n",
    "#write your code\n",
    "    m=len(y)\n",
    "    \n",
    "    z_wb=np.dot(X,w)+b\n",
    "    \n",
    "    h=sigmoid(z_wb)\n",
    "    \n",
    "    total_cost=-(1/m)*np.sum(y*np.log(h)+(1-y)*np.log(1-h))+(lambda_/(2*m))*np.sum(w**2)\n",
    "    return total_cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "MPOvLzL5H5-5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost at test w,b: 11.777\n"
     ]
    },
    {
     "ename": "AssertionError",
     "evalue": "Wrong output. Expected: 2.15510667 got: 2.7593242626823304",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[22], line 9\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCost at test w,b: \u001b[39m\u001b[38;5;132;01m{:.3f}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mformat(cost))\n\u001b[1;32m      8\u001b[0m \u001b[38;5;66;03m# test\u001b[39;00m\n\u001b[0;32m----> 9\u001b[0m \u001b[43mcompute_cost_test\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcompute_cost\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[14], line 17\u001b[0m, in \u001b[0;36mcompute_cost_test\u001b[0;34m(target)\u001b[0m\n\u001b[1;32m     15\u001b[0m b \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[1;32m     16\u001b[0m result \u001b[38;5;241m=\u001b[39m target(X, y, w, b)\n\u001b[0;32m---> 17\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m np\u001b[38;5;241m.\u001b[39misclose(result, \u001b[38;5;241m2.15510667\u001b[39m), \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWrong output. Expected: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;241m2.15510667\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m got: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mresult\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m     19\u001b[0m X \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mrandn(\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m3\u001b[39m)\n\u001b[1;32m     20\u001b[0m y \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m0\u001b[39m])\n",
      "\u001b[0;31mAssertionError\u001b[0m: Wrong output. Expected: 2.15510667 got: 2.7593242626823304"
     ]
    }
   ],
   "source": [
    "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,b: {:.3f}'.format(cost))\n",
    "\n",
    "\n",
    "# test\n",
    "compute_cost_test(compute_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ULkWUBkO7ffh"
   },
   "outputs": [],
   "source": [
    "#compute regularised cost\n",
    "def compute_cost_reg(X, y, w, b, lambda_ = 1):\n",
    "#write your code\n",
    "    m = X.shape[0]\n",
    "    z_wb = np.dot(X, w) + b\n",
    "    h = sigmoid(z_wb)\n",
    "    \n",
    "    # Cost function\n",
    "    cost = (-1 / m) * (np.dot(y, np.log(h)) + np.dot((1 - y), np.log(1 - h)))\n",
    "    \n",
    "    # Regularization term (excluding bias term)\n",
    "    reg_term = (lambda_ / (2 * m)) * np.sum(np.square(w))\n",
    "    \n",
    "    total_cost = cost + reg_term\n",
    "\n",
    "\n",
    "\n",
    "    return total_cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "id": "OhFbPakDGKQj"
   },
   "outputs": [],
   "source": [
    "# @title DO NOT EDIT THIS CODE\n",
    "def compute_cost_reg_test(target):\n",
    "    np.random.seed(1)\n",
    "    w = np.random.randn(3)\n",
    "    b = 0.4\n",
    "    X = np.random.randn(6, 3)\n",
    "    y = np.array([0, 1, 1, 0, 1, 1])\n",
    "    lambda_ = 0.1\n",
    "    expected_output = target(X, y, w, b, lambda_)\n",
    "\n",
    "    assert np.isclose(expected_output, 0.5469746792761936), f\"Wrong output. Expected: {0.5469746792761936} got:{expected_output}\"\n",
    "\n",
    "    w = np.random.randn(5)\n",
    "    b = -0.6\n",
    "    X = np.random.randn(8, 5)\n",
    "    y = np.array([1, 0, 1, 0, 0, 1, 0, 1])\n",
    "    lambda_ = 0.01\n",
    "    output = target(X, y, w, b, lambda_)\n",
    "    assert np.isclose(output, 1.2608591964119995), f\"Wrong output. Expected: {1.2608591964119995} got:{output}\"\n",
    "\n",
    "    w = np.array([2, 2, 2, 2, 2])\n",
    "    b = 0\n",
    "    X = np.zeros((8, 5))\n",
    "    y = np.array([0.5] * 8)\n",
    "    lambda_ = 3\n",
    "    output = target(X, y, w, b, lambda_)\n",
    "    expected = -np.log(0.5) + 3. / (2. * 8.) * 20.\n",
    "    assert np.isclose(output, expected), f\"Wrong output. Expected: {expected} got:{output}\"\n",
    "\n",
    "    print('\\033[92mAll tests passed!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jO14e7OD7syR"
   },
   "outputs": [],
   "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(\"Regularised cost :\", cost)\n",
    "\n",
    "#test\n",
    "compute_cost_reg_test(compute_cost_reg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "cellView": "form",
    "id": "plQBUPM2IRei"
   },
   "outputs": [],
   "source": [
    "# @title DO NOT EDIT THIS CODE\n",
    "def compute_gradient_test(target):\n",
    "    np.random.seed(1)\n",
    "    X = np.random.randn(7, 3)\n",
    "    y = np.array([1, 0, 1, 0, 1, 1, 0])\n",
    "    test_w = np.array([1, 0.5, -0.35])\n",
    "    test_b = 1.7\n",
    "    dj_db, dj_dw  = target(X, y, test_w, test_b)\n",
    "\n",
    "    assert np.isclose(dj_db, 0.28936094), f\"Wrong value for dj_db. Expected: {0.28936094} got: {dj_db}\"\n",
    "    assert dj_dw.shape == test_w.shape, f\"Wrong shape for dj_dw. Expected: {test_w.shape} got: {dj_dw.shape}\"\n",
    "    assert np.allclose(dj_dw, [-0.11999166, 0.41498775, -0.71968405]), f\"Wrong values for dj_dw. Got: {dj_dw}\"\n",
    "\n",
    "    print('\\033[92mTests passed!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "v27SzhYX8-ug"
   },
   "outputs": [],
   "source": [
    "#compute gradient\n",
    "def compute_gradient(X, y, w, b, lambda_=None):\n",
    "#write your code\n",
    "    m, n = X.shape\n",
    "    z_wb = np.dot(X, w) + b\n",
    "    h = sigmoid(z_wb)\n",
    "    \n",
    "    error = h - y\n",
    "    dj_dw = (1 / m) * np.dot(X.T, error)\n",
    "    dj_db = (1 / m) * np.sum(error)\n",
    "    \n",
    "    if lambda_ is not None:\n",
    "        dj_dw += (lambda_ / m) * w\n",
    "    \n",
    "    return dj_db, dj_dw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "WLmFL2yuIPUA"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dj_db at test_w: -0.4915254236924827\n",
      "dj_dw at test_w: [-0.008601361012465381, -0.09147300847306207]\n",
      "\u001b[92mTests passed!\n"
     ]
    }
   ],
   "source": [
    "test_w = np.array([ 0.2, -0.5])\n",
    "test_b = -24\n",
    "dj_db, dj_dw  = compute_gradient(X_train, y_train, test_w, test_b)\n",
    "\n",
    "print('dj_db at test_w:', dj_db)\n",
    "print('dj_dw at test_w:', dj_dw.tolist())\n",
    "\n",
    "# test\n",
    "compute_gradient_test(compute_gradient)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "TGfUArz09TMl"
   },
   "outputs": [],
   "source": [
    "#compute regularised gradient\n",
    "def compute_gradient_reg(X, y, w, b, lambda_=1):\n",
    "#write your code\n",
    "    m, n = X.shape\n",
    "    z_wb = np.dot(X, w) + b\n",
    "    h = sigmoid(z_wb)\n",
    "    error = h - y\n",
    "    dj_dw = (1 / m) * np.dot(X.T, error) + (lambda_ / m) * w\n",
    "    dj_db = (1 / m) * np.sum(error)\n",
    "    \n",
    "    return dj_db, dj_dw\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "cellView": "form",
    "id": "KNRCWIc8G2cp"
   },
   "outputs": [],
   "source": [
    "# @title DO NOT EDIT THIS CODE\n",
    "def compute_gradient_reg_test(target):\n",
    "    np.random.seed(1)\n",
    "    w = np.random.randn(5)\n",
    "    b = 0.2\n",
    "    X = np.random.randn(7, 5)\n",
    "    y = np.array([0, 1, 1, 0, 1, 1, 0])\n",
    "    lambda_ = 0.1\n",
    "    expected1 = (-0.1506447567869257, np.array([ 0.19530838, -0.00632206,  0.19687367,  0.15741161,  0.02791437]))\n",
    "    dj_db, dj_dw = target(X, y, w, b, lambda_)\n",
    "\n",
    "    assert np.isclose(dj_db, expected1[0]), f\"Wrong dj_db. Expected: {expected1[0]} got: {dj_db}\"\n",
    "    assert np.allclose(dj_dw, expected1[1]), f\"Wrong dj_dw. Expected: {expected1[1]} got: {dj_dw}\"\n",
    "\n",
    "\n",
    "    w = np.random.randn(7)\n",
    "    b = 0\n",
    "    X = np.random.randn(7, 7)\n",
    "    y = np.array([1, 0, 0, 0, 1, 1, 0])\n",
    "    lambda_ = 0\n",
    "    expected2 = (0.02660329857573818, np.array([ 0.23567643, -0.06921029, -0.19705212, -0.0002884 ,  0.06490588,\n",
    "        0.26948175,  0.10777992]))\n",
    "    dj_db, dj_dw = target(X, y, w, b, lambda_)\n",
    "    assert np.isclose(dj_db, expected2[0]), f\"Wrong dj_db. Expected: {expected2[0]} got: {dj_db}\"\n",
    "    assert np.allclose(dj_dw, expected2[1]), f\"Wrong dj_dw. Expected: {expected2[1]} got: {dj_dw}\"\n",
    "\n",
    "    print('\\033[92mTests passed!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "id": "3_of_BHJ9hEc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dj_db: 0.07138288792343654\n",
      "\u001b[92mTests passed!\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_db, dj_dw = compute_gradient_reg(X_mapped, y_train, initial_w, initial_b, lambda_)\n",
    "\n",
    "print(f\"dj_db: {dj_db}\" )\n",
    "#test\n",
    "compute_gradient_reg_test(compute_gradient_reg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "id": "c5y3Nb9Z_SC4"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'compute_cost_reg' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[34], line 28\u001b[0m\n\u001b[1;32m     23\u001b[0m         J_history\u001b[38;5;241m.\u001b[39mappend(cost)\n\u001b[1;32m     25\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m w, b, J_history, _\n\u001b[1;32m     27\u001b[0m w,b, J_history,_ \u001b[38;5;241m=\u001b[39m gradient_descent(X_mapped, y_train, initial_w, initial_b,\n\u001b[0;32m---> 28\u001b[0m                                     \u001b[43mcompute_cost_reg\u001b[49m, compute_gradient_reg,\n\u001b[1;32m     29\u001b[0m                                     alpha, iterations, lambda_)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'compute_cost_reg' is not defined"
     ]
    }
   ],
   "source": [
    "np.random.seed(1)\n",
    "initial_w = np.random.rand(X_mapped.shape[1])-0.5\n",
    "initial_b = 1.\n",
    "lambda_ = 0.01\n",
    "iterations = 1000\n",
    "alpha = 0.01\n",
    "def gradient_descent(X_mapped, y_train, initial_w, initial_b,\n",
    "                                    compute_cost_reg, compute_gradient_reg,\n",
    "                                    alpha, iterations, lambda_):\n",
    "\n",
    "#write your code\n",
    "    w = initial_w\n",
    "    b = initial_b\n",
    "    J_history = []\n",
    "\n",
    "    for i in range(iterations):\n",
    "        cost = compute_cost_reg(X_mapped, y_train, w, b, lambda_)\n",
    "        dj_db, dj_dw = compute_gradient_reg(X_mapped, y_train, w, b, lambda_)\n",
    "\n",
    "        w = w - alpha * dj_dw\n",
    "        b = b - alpha * dj_db\n",
    "\n",
    "        J_history.append(cost)\n",
    "\n",
    "    return w, b, J_history, _\n",
    "\n",
    "w,b, J_history,_ = gradient_descent(X_mapped, y_train, initial_w, initial_b,\n",
    "                                    compute_cost_reg, compute_gradient_reg,\n",
    "                                    alpha, iterations, lambda_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cqSOrJsTAf9p"
   },
   "outputs": [],
   "source": [
    "#plot decision boundary\n",
    "def plot_decision_boundary(w,b,X,y):\n",
    "\n",
    "    plot_data(X[:, 0:2], y)\n",
    "\n",
    "    if X.shape[1] <= 2:\n",
    "        plot_x = np.array([min(X[:, 0]), max(X[:, 0])])\n",
    "        plot_y = (-1. / w[1]) * (w[0] * plot_x + b)\n",
    "\n",
    "        plt.plot(plot_x, plot_y, c=\"b\")\n",
    "\n",
    "    else:\n",
    "        u = np.linspace(-1, 1.5, 50)\n",
    "        v = np.linspace(-1, 1.5, 50)\n",
    "\n",
    "        z = np.zeros((len(u), len(v)))\n",
    "\n",
    "\n",
    "        for i in range(len(u)):\n",
    "            for j in range(len(v)):\n",
    "                z[i,j] = sig(np.dot(map_feature(u[i], v[j]), w) + b)\n",
    "\n",
    "\n",
    "        z = z.T\n",
    "\n",
    "\n",
    "        plt.contour(u,v,z, levels = [0.5], colors=\"g\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "etir_m_AAyYC"
   },
   "outputs": [],
   "source": [
    "plot_decision_boundary(w, b, X_mapped, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MD2Dup4OA1ew"
   },
   "outputs": [],
   "source": [
    "#predict your training model\n",
    "def predict(X, w, b):\n",
    "  m,n=X.shape\n",
    "  p=np.zeros(m)\n",
    "  #write your code\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "  return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TAhIPFIsBTjk"
   },
   "outputs": [],
   "source": [
    "p = predict(X_mapped, w, b)\n",
    "\n",
    "print('Accuracy of training model: %f'%(np.mean(p == y_train) * 100))"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}