assignment06.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "assignment06.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMG8glw17sWijaJxaL8jDXE",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/dlguswn3659/class-MachineLearning/blob/master/assignment06.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pMcbWdbh98uY",
        "colab_type": "text"
      },
      "source": [
        "# **Machine Learning Assignment06** #\n",
        "\n",
        "Name : 이현주\n",
        "\n",
        "Student # : 20184060"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SmK4D4Gm-Owm",
        "colab_type": "text"
      },
      "source": [
        "# **1. Plot the training data [2pt]**\n",
        "\n",
        "- plot the training data points (x,y) with their labels / in colors (blue for label 0 and red for label 1)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xPQTutBY9LYV",
        "colab_type": "code",
        "outputId": "9403777e-80a2-4c50-907d-e26697cd5d1b",
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "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",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": ""
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 77
        }
      },
      "source": [
        "%matplotlib inline\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib as mpl\n",
        "import seaborn as sns\n",
        "import matplotlib.animation as animation\n",
        "from scipy import stats \n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "from sklearn.datasets.samples_generator import make_regression \n",
        "import csv\n",
        "import math\n",
        "from google.colab import files\n",
        "\n",
        "uploaded = files.upload()\n",
        "\n",
        "data    = np.genfromtxt(\"data-nonlinear.txt\", delimiter=',')\n",
        "\n",
        "pointX  = data[:, 0]\n",
        "pointY  = data[:, 1]\n",
        "label   = data[:, 2]\n",
        "\n",
        "pointX0 = pointX[label == 0]\n",
        "pointY0 = pointY[label == 0]\n",
        "\n",
        "pointX1 = pointX[label == 1]\n",
        "pointY1 = pointY[label == 1]\n",
        "\n",
        "# plt.figure()\n",
        "# plt.scatter(pointX0, pointY0, c='b')\n",
        "# plt.scatter(pointX1, pointY1, c='r')\n",
        "# plt.tight_layout()\n",
        "# plt.gca().set_aspect('equal', adjustable='box')\n",
        "# plt.show()"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-614f9c72-c00f-41b3-a94a-9a735065492f\" name=\"files[]\" multiple disabled />\n",
              "     <output id=\"result-614f9c72-c00f-41b3-a94a-9a735065492f\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Saving data-nonlinear.txt to data-nonlinear.txt\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZqqLOKHkCI_o",
        "colab_type": "text"
      },
      "source": [
        "# **2. Write down the high dimensional function g(x,y;θ) [2pt]**\n",
        "\n",
        "- write down the equation for the non-linear function g(x,y;θ) used for the classifier in LaTeX format"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oJW9KhFyKgRd",
        "colab_type": "text"
      },
      "source": [
        "$$\n",
        "g(x, y; \\theta) = \\theta_0f_0(x, y) + \\theta_1f_1(x, y) + ⋯ + \\theta_{k-1}f_{k-1}(x, y)\\\\\n",
        "$$\n",
        "\n",
        "\n",
        "$$\n",
        "g(x, y; \\theta) = \\theta_0 + \\theta_1x + \\theta_2y + \\theta_3x^2 + \\theta_4xy + \\theta_5y^2 + \\theta_6x^3 + \\theta_7x^2y + \\theta_8xy^2 + \\theta_9y^3 + \\theta_{10}x^4 + \\theta_{11}x^3y + \\theta_{12}x^2y^2 + \\theta_{13}xy^3 + \\theta_{14}y^4\n",
        "$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mujVAKAmCNjP",
        "colab_type": "text"
      },
      "source": [
        "# **3. Plot the training error [3pt]**\n",
        "\n",
        "- plot the training error J(θ) at every iteration of gradient descent until convergence (in blue color)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1mEMEUWYDPWo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "X = pointX #전체 x\n",
        "y = np.array(pointY,dtype=float)\n",
        "label = np.array(label,dtype=float)\n",
        "# print(len(y))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UNLXbC6gS51L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def g_function(X, y, theta, it, i):\n",
        "  return  (theta[0][it] + theta[1][it]*X[i] + theta[2][it]*y[i] + theta[3][it]*X[i]*X[i] +\n",
        "          theta[4][it]*X[i]*y[i] + theta[5][it]*y[i]*y[i] + theta[6][it]*X[i]*X[i]*X[i] + theta[7][it]*X[i]*X[i]*y[i] +\n",
        "          theta[8][it]*X[i]*y[i]*y[i] + theta[9][it]*y[i]*y[i]*y[i] + theta[10][it]*X[i]*X[i]*X[i]*X[i] + theta[11][it]*X[i]*X[i]*X[i]*y[i] +\n",
        "          theta[12][it]*X[i]*X[i]*y[i]*y[i] + theta[13][it]*X[i]*y[i]*y[i]*y[i] + theta[14][it]*y[i]*y[i]*y[i]*y[i] \n",
        "          #  + theta[15][it]*X[i]*X[i]*X[i]*X[i]*X[i]\n",
        "           )"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3nlfxBVRQEQo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def gradient_descent(X,y,label,theta,learning_rate=0.001,iterations=30000):\n",
        "    \n",
        "    m = len(y)\n",
        "\n",
        "    cost_history = np.zeros(iterations)\n",
        "    theta_history = np.zeros((iterations,15))\n",
        "    for it in range(iterations):\n",
        "        pred = 0\n",
        "\n",
        "        pred0 = 0\n",
        "        pred1 = 0\n",
        "        pred2 = 0\n",
        "        pred3 = 0\n",
        "        pred4 = 0\n",
        "        pred5 = 0\n",
        "        pred6 = 0\n",
        "        pred7 = 0\n",
        "        pred8 = 0\n",
        "        pred9 = 0\n",
        "        pred10 = 0\n",
        "        pred11 = 0\n",
        "        pred12 = 0\n",
        "        pred13 = 0\n",
        "        pred14 = 0\n",
        "        # pred15 = 0\n",
        "\n",
        "        for i in range(0, m):\n",
        "          # print(i)\n",
        "          #cost 함수\n",
        "          pred = pred + ((-1)*label[i]*math.log(1/(1 + math.exp((-1)*g_function(X, y, theta, it, i))))-((1-label[i])*math.log(1 - (-1)*(1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))))))\n",
        "          \n",
        "          #  σ(z)   =    (1/(1 + math.exp((-1)*(theta[0][it] + theta[1][it]*X[i] + theta[2][it]*y[i]))))\n",
        "\n",
        "          #theta함수\n",
        "          pred0 = pred0 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])\n",
        "          pred1 = pred1 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*X[i]\n",
        "          pred2 = pred2 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*y[i]\n",
        "          pred3 = pred3 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*X[i]*X[i]\n",
        "          pred4 = pred4 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*X[i]*y[i]\n",
        "          pred5 = pred5 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*y[i]*y[i]\n",
        "          pred6 = pred6 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*X[i]*X[i]*X[i]\n",
        "          pred7 = pred7 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*X[i]*X[i]*y[i]\n",
        "          pred8 = pred8 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*X[i]*y[i]*y[i]\n",
        "          pred9 = pred9 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*y[i]*y[i]*y[i]\n",
        "          pred10 = pred10 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*X[i]*X[i]*X[i]*X[i]\n",
        "          pred11 = pred11 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*X[i]*X[i]*X[i]*y[i]\n",
        "          pred12 = pred12 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*X[i]*X[i]*y[i]*y[i]\n",
        "          pred13 = pred13 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*X[i]*y[i]*y[i]*y[i]\n",
        "          pred14 = pred14 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*y[i]*y[i]*y[i]*y[i]\n",
        "          # pred15 = pred15 + ((1/(1 + math.exp((-1)*g_function(X, y, theta, it, i)))) - label[i])*X[i]*X[i]*X[i]*X[i]*X[i]\n",
        "        \n",
        "        theta[0][it + 1] = theta[0][it] - (1/m)*learning_rate*pred0\n",
        "        theta[1][it + 1] = theta[1][it] - (1/m)*learning_rate*pred1\n",
        "        theta[2][it + 1] = theta[2][it] - (1/m)*learning_rate*pred2\n",
        "        theta[3][it + 1] = theta[3][it] - (1/m)*learning_rate*pred3\n",
        "        theta[4][it + 1] = theta[4][it] - (1/m)*learning_rate*pred4\n",
        "        theta[5][it + 1] = theta[5][it] - (1/m)*learning_rate*pred5\n",
        "        theta[6][it + 1] = theta[6][it] - (1/m)*learning_rate*pred6\n",
        "        theta[7][it + 1] = theta[7][it] - (1/m)*learning_rate*pred7\n",
        "        theta[8][it + 1] = theta[8][it] - (1/m)*learning_rate*pred8\n",
        "        theta[9][it + 1] = theta[9][it] - (1/m)*learning_rate*pred9\n",
        "        theta[10][it + 1] = theta[10][it] - (1/m)*learning_rate*pred10\n",
        "        theta[11][it + 1] = theta[11][it] - (1/m)*learning_rate*pred11\n",
        "        theta[12][it + 1] = theta[12][it] - (1/m)*learning_rate*pred12\n",
        "        theta[13][it + 1] = theta[13][it] - (1/m)*learning_rate*pred13\n",
        "        theta[14][it + 1] = theta[14][it] - (1/m)*learning_rate*pred14\n",
        "        # theta[15][it + 1] = theta[15][it] - (1/m)*learning_rate*pred15\n",
        "\n",
        "        theta_history[it][0] = theta[0][it]\n",
        "        theta_history[it][1] = theta[1][it]\n",
        "        theta_history[it][2] = theta[2][it]\n",
        "        theta_history[it][3] = theta[3][it]\n",
        "        theta_history[it][4] = theta[4][it]\n",
        "        theta_history[it][5] = theta[5][it]\n",
        "        theta_history[it][6] = theta[6][it]\n",
        "        theta_history[it][7] = theta[7][it]\n",
        "        theta_history[it][8] = theta[8][it]\n",
        "        theta_history[it][9] = theta[9][it]\n",
        "        theta_history[it][10] = theta[10][it]\n",
        "        theta_history[it][11] = theta[11][it]\n",
        "        theta_history[it][12] = theta[12][it]\n",
        "        theta_history[it][13] = theta[13][it]\n",
        "        theta_history[it][14] = theta[14][it]\n",
        "        # theta_history[it][15] = theta[15][it]\n",
        "\n",
        "        cost_history[it]  = (1/m) * pred\n",
        "        \n",
        "    return theta, cost_history, theta_history"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OO4LdAVmQG_e",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "lr =0.5\n",
        "n_iter = 2000\n",
        "\n",
        "theta = np.zeros((15, n_iter + 1))  \n",
        "#theta 전부 0으로 초기화\n",
        "# theta[0][0] = 1.28\n",
        "# theta[1][0] = 0.56\n",
        "# theta[2][0] = 1.11\n",
        "# theta[3][0] = -2.20\n",
        "# theta[4][0] = -0.92\n",
        "# theta[5][0] = -1.62\n",
        "# theta[6][0] = -0.03\n",
        "# theta[7][0] = -0.36\n",
        "# theta[8][0] = -0.33\n",
        "# theta[9][0] = -0.47\n",
        "# theta[10][0] = -1.67\n",
        "# theta[11][0] = -0.05\n",
        "# theta[12][0] = -0.62\n",
        "# theta[13][0] = -0.26\n",
        "# theta[14][0] = -1.54\n",
        "\n",
        "X_b = np.c_[np.ones((len(X),0)),X]\n",
        "X_b = np.array(X_b,dtype=float)\n",
        "# print(X_b.shape)\n",
        "# print(X_b.dtype)\n",
        "# print(y.dtype)\n",
        "theta,cost_history,theta_history = gradient_descent(X_b,y,label,theta,lr,n_iter)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5hGch925QUBz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# fig,ax = plt.subplots(figsize=(12,8))\n",
        "\n",
        "theta0_history = []\n",
        "theta1_history = []\n",
        "theta2_history = []\n",
        "theta3_history = []\n",
        "theta4_history = []\n",
        "theta5_history = []\n",
        "theta6_history = []\n",
        "theta7_history = []\n",
        "theta8_history = []\n",
        "theta9_history = []\n",
        "theta10_history = []\n",
        "theta11_history = []\n",
        "theta12_history = []\n",
        "theta13_history = []\n",
        "theta14_history = []\n",
        "# theta15_history = []\n",
        "\n",
        "for it in range(n_iter):\n",
        "  theta0_history.append(theta_history[it][0])\n",
        "  theta1_history.append(theta_history[it][1])\n",
        "  theta2_history.append(theta_history[it][2])\n",
        "  theta3_history.append(theta_history[it][3])\n",
        "  theta4_history.append(theta_history[it][4])\n",
        "  theta5_history.append(theta_history[it][5])\n",
        "  theta6_history.append(theta_history[it][6])\n",
        "  theta7_history.append(theta_history[it][7])\n",
        "  theta8_history.append(theta_history[it][8])\n",
        "  theta9_history.append(theta_history[it][9])\n",
        "  theta10_history.append(theta_history[it][10])\n",
        "  theta11_history.append(theta_history[it][11])\n",
        "  theta12_history.append(theta_history[it][12])\n",
        "  theta13_history.append(theta_history[it][13])\n",
        "  theta14_history.append(theta_history[it][14])\n",
        "  # theta15_history.append(theta_history[it][15])\n",
        "\n",
        "# ax.set_ylabel('Theta')\n",
        "# ax.set_xlabel('Iterations')\n",
        "# _=ax.plot(range(n_iter),theta0_history,'b.', color = 'red')\n",
        "# _=ax.plot(range(n_iter),theta1_history,'b.', color = 'green')\n",
        "# _=ax.plot(range(n_iter),theta2_history,'b.', color = 'blue')\n",
        "\n",
        "# for it in range(0, 15):\n",
        "#   print(theta_history[-1][it])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9I8EKgyNcWG7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# fig,ax = plt.subplots(figsize=(12,8))\n",
        "\n",
        "# n_iter = 50\n",
        "# cost_history = new_cost(X_b,y,theta,n_iter)\n",
        "\n",
        "# print(cost_history[-1])\n",
        "\n",
        "# ax.set_ylabel('J(Theta)')\n",
        "# ax.set_xlabel('Iterations')\n",
        "# _=ax.plot(range(n_iter),cost_history,'b.')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W0_y4h3lCOEW",
        "colab_type": "text"
      },
      "source": [
        "# **4. Plot the training accuracy [3pt]**\n",
        "\n",
        "- plot the training accuracy at every iteration of gradient descent until convergence (in red color)\n",
        "- the score will be given depending on the accuracy"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0wj0uBA9DPzg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nv_zAWupCOVI",
        "colab_type": "text"
      },
      "source": [
        "# **5. Write down the final training accuracy [5pt]**\n",
        "\n",
        "- present the final training accuracy in number (%) at convergence\n",
        "- the score will be given depending on the accuracy"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1EHCmX92hVJs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "122cadbc-c78e-4447-bce0-095378bc4e9c"
      },
      "source": [
        "%pylab inline \n",
        "import numpy as np \n",
        "import pandas as pd \n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Populating the interactive namespace from numpy and matplotlib\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YnH_mOBcdBAv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def sigmoid(z): \n",
        "  g = 1 / (1 + np.exp(-z)) \n",
        "  \n",
        "  return g \n",
        "  \n",
        "# print('sigmoid(10) = %s, sigmoid(-10) = %s, sigmoid(0) = %s' % (sigmoid(10), sigmoid(-10), sigmoid(0)))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1AHVbDkFdHv1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def mapFeature(X1, X2): \n",
        "  degree =  4\n",
        "  #print(X1.shape) \n",
        "  m = np.size(X1) \n",
        "  out = np.ones(m) \n",
        "  res = [] \n",
        "  \n",
        "  res.append(out) \n",
        "  \n",
        "  for i in np.arange(1, degree + 1): \n",
        "    for j in np.arange(0, i + 1): \n",
        "      out1 = (X1 ** (i - j)) * (X2 ** j) \n",
        "      res.append(out1) \n",
        "      \n",
        "  return np.array(res).T \n",
        "\n",
        "data = matrix(data)\n",
        "\n",
        "X = data[:, 0:2] \n",
        "y = data[:, 2] \n",
        "\n",
        "X = np.array(X)\n",
        "y = np.array(y)\n",
        "      \n",
        "X_reg = mapFeature(X[:, 0], X[:, 1]) \n",
        "# print(X_reg[0:2, :])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3YW4_wccdKuS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import scipy.optimize as op \n",
        "\n",
        "def myCostReg(theta, X, y, s_lambda): \n",
        "  \n",
        "  X = matrix(X) \n",
        "\n",
        "  J = 0 \n",
        "  grad = np.zeros(np.size(theta)) \n",
        "  m, n = X.shape \n",
        "  y = y.reshape((m, 1)) \n",
        "  theta = theta.reshape((n, 1)) \n",
        "\n",
        "  theta_0 = theta[0] \n",
        "  theta_j = theta[1:] \n",
        "\n",
        "  theta = np.matrix(theta) \n",
        "  sum_theta_square = np.sum(theta_j ** 2) \n",
        "  predictions = X * theta \n",
        "  sig_term = sigmoid(predictions)\n",
        "\n",
        "  J = 1/m * sum(np.multiply(-y, log(sig_term)) - np.multiply((1 - y), log(1 - sig_term))) + s_lambda / (2 * m) * sum_theta_square \n",
        "  \n",
        "  return J \n",
        "  \n",
        "def myGradientReg(theta, X, y, s_lambda): \n",
        " \n",
        "  X = matrix(X) \n",
        "\n",
        "  J = 0 \n",
        "  grad = np.zeros(np.size(theta)) \n",
        "  m, n = X.shape \n",
        "  y = y.reshape((m, 1)) \n",
        "  theta = theta.reshape((n, 1)) \n",
        "\n",
        "  theta_0 = theta[0] \n",
        "  theta_j = theta[1:] \n",
        " \n",
        "  theta = np.matrix(theta) \n",
        "\n",
        "  predictions = X * theta \n",
        "  sig_term = sigmoid(predictions) \n",
        "\n",
        "  errors = (sig_term - y) \n",
        "\n",
        "  delta_0 = 1/m * errors.T * X[:, 0] \n",
        "\n",
        "  delta = 1/m * errors.T * X[:, 1:]\n",
        "\n",
        "  regular = s_lambda / m * theta_j \n",
        "  delta_j = delta.T + regular \n",
        "  grad[0] = delta_0 \n",
        "  grad[1:] = delta_j.T \n",
        "   \n",
        "  return grad.flatten() \n",
        "   \n",
        "initial_theta = np.zeros((X_reg.shape[1], 1)) \n",
        "s_lambda = 1 \n",
        "\n",
        "Result = op.minimize(fun = myCostReg, x0 = initial_theta, args = (X_reg, y, s_lambda), method = 'TNC', jac = myGradientReg); \n",
        "cost = Result.fun \n",
        "theta = Result.x \n",
        "\n",
        "theta[0] = theta_history[1500][0]\n",
        "theta[1] = theta_history[1500][1]\n",
        "theta[2] = theta_history[1500][2]\n",
        "theta[3] = theta_history[1500][3]\n",
        "theta[4] = theta_history[1500][4]\n",
        "theta[5] = theta_history[1500][5]\n",
        "theta[6] = theta_history[1500][6]\n",
        "theta[7] = theta_history[1500][7]\n",
        "theta[8] = theta_history[1500][8]\n",
        "theta[9] = theta_history[1500][9]\n",
        "theta[10] = theta_history[1500][10]\n",
        "theta[11] = theta_history[1500][11]\n",
        "theta[12] = theta_history[1500][12]\n",
        "theta[13] = theta_history[1500][13]\n",
        "theta[14] = theta_history[1500][14]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7GySxSkwdPI_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def predict(theta, X): \n",
        "  m = matrix(X) \n",
        "  m, n = X.shape \n",
        "  theta = theta.reshape((n, 1)) \n",
        "  theta = matrix(theta) \n",
        "  p = np.zeros((m, 1)) \n",
        "  p = sigmoid(X * theta) >= 0.5; \n",
        "  \n",
        "  return p "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cPSwk7BZdQzA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "p = predict(theta, X_reg) "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MokllgPaCOmA",
        "colab_type": "text"
      },
      "source": [
        "# **6. Plot the optimal classifier superimposed on the training data [5pt]**\n",
        "\n",
        "- plot the boundary of the optimal classifier at convergence (in green color)\n",
        "- the boundary of the classifier is defined by {(x,y)∣σ(g(x,y;θ))=0.5}={(x,y)∣g(x,y;θ)=0}\n",
        "- plot the training data points (x,y) with their labels lll in colors superimposed on the illustration of the classifier (blue for label 0 and red for label 1)\n",
        "- you can use contour function in python3\n",
        "- the score will be given depending on the accuracy"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1FDAbh1m9VU3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def plotBoundary(theta, X, y): \n",
        "  \n",
        "  if np.size(X, 1) <= 3: \n",
        "    plot_x = np.array([np.min(X[:, 1]) - 2, np.max(X[:, 1] + 2)]) \n",
        "    plot_y = (-1 / theta[2]) * (theta[1] * plot_x + theta[0]) \n",
        "    plot(plot_x, plot_y) \n",
        "    plt.legend(('Admitted', 'Not admitted'), loc='upper right') \n",
        "  \n",
        "  else: \n",
        "\n",
        "    u = linspace(-1, 1.5, 800) \n",
        "    v = linspace(-1, 1.5, 800) \n",
        "    z = np.zeros((np.size(u), np.size(v))) \n",
        "\n",
        "    for i in np.arange(np.size(u)): \n",
        "      for j in np.arange(np.size(v)): \n",
        "        z[i, j] = np.sum(mapFeature(u[i], v[j]) * theta) \n",
        "        \n",
        "        z = z.T \n",
        "\n",
        "    plt.figure()\n",
        "    plt.scatter(pointX0, pointY0, c='b')\n",
        "    plt.scatter(pointX1, pointY1, c='r')\n",
        "    plt.tight_layout()\n",
        "    plt.gca().set_aspect('equal', adjustable='box')\n",
        "    plt.contour(u, v, z) "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1zIajz9TdTcB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# plotBoundary(theta, X_reg, y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7Fw8FdyuaVRw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "accuracy_history = np.zeros(1500)\n",
        "\n",
        "for i in range(1500):\n",
        "  p = predict(theta_history[i], X_reg) \n",
        "  accuracy_history[i] = np.mean(double(p == y))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HvSIT__RZzMY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# fig,ax = plt.subplots(figsize=(12,8))\n",
        "\n",
        "# ax.set_ylabel('accuracy')\n",
        "# ax.set_xlabel('Iterations')\n",
        "# _=ax.plot(range(1500),accuracy_history,'r.')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "jRZdvhoye2gw"
      },
      "source": [
        "# **Machine Learning Assignment06** #\n",
        "\n",
        "Name : 이현주\n",
        "\n",
        "Student # : 20184060"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "EdKgNV-Ee_G2"
      },
      "source": [
        "# **1. Plot the training data [2pt]**\n",
        "\n",
        "- plot the training data points (x,y) with their labels / in colors (blue for label 0 and red for label 1)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SIwuCnLsfizZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "outputId": "46655423-cb2d-475b-bab9-703ad3d3614e"
      },
      "source": [
        "plt.figure()\n",
        "plt.scatter(pointX0, pointY0, c='b')\n",
        "plt.scatter(pointX1, pointY1, c='r')\n",
        "plt.tight_layout()\n",
        "plt.gca().set_aspect('equal', adjustable='box')\n",
        "plt.show()"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "YYc-7F4_fD4v"
      },
      "source": [
        "# **2. Write down the high dimensional function g(x,y;θ) [2pt]**\n",
        "\n",
        "- write down the equation for the non-linear function g(x,y;θ) used for the classifier in LaTeX format"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "f_dqkvMXfHdw"
      },
      "source": [
        "$$\n",
        "g(x, y; \\theta) = \\theta_0f_0(x, y) + \\theta_1f_1(x, y) + ⋯ + \\theta_{k-1}f_{k-1}(x, y)\\\\\n",
        "$$\n",
        "\n",
        "\n",
        "$$\n",
        "g(x, y; \\theta) = \\theta_0 + \\theta_1x + \\theta_2y + \\theta_3x^2 + \\theta_4xy + \\theta_5y^2 + \\theta_6x^3 + \\theta_7x^2y + \\theta_8xy^2 + \\theta_9y^3 + \\theta_{10}x^4 + \\theta_{11}x^3y + \\theta_{12}x^2y^2 + \\theta_{13}xy^3 + \\theta_{14}y^4\n",
        "$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "3VyGwLJBfML9"
      },
      "source": [
        "# **3. Plot the training error [3pt]**\n",
        "\n",
        "- plot the training error J(θ) at every iteration of gradient descent until convergence (in blue color)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "53ihfgRqfuZY",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 497
        },
        "outputId": "9681e7c8-db97-4670-ea1d-8cc7514eb3ca"
      },
      "source": [
        "fig,ax = plt.subplots(figsize=(12,8))\n",
        "\n",
        "ax.set_ylabel('J(Theta)')\n",
        "ax.set_xlabel('Iterations')\n",
        "_=ax.plot(range(n_iter),cost_history,'b.')"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Wv2Ki0iUfaYM"
      },
      "source": [
        "# **4. Plot the training accuracy [3pt]**\n",
        "\n",
        "- plot the training accuracy at every iteration of gradient descent until convergence (in red color)\n",
        "- the score will be given depending on the accuracy"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DgyztY7Sf2Qd",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 497
        },
        "outputId": "9608b52b-544f-4b2e-f80a-54da8f7239fd"
      },
      "source": [
        "fig,ax = plt.subplots(figsize=(12,8))\n",
        "\n",
        "ax.set_ylabel('accuracy')\n",
        "ax.set_xlabel('Iterations')\n",
        "_=ax.plot(range(1500),accuracy_history,'r.')"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtcAAAHgCAYAAABuGUHVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3df5Bld10n/PfHSSZB5EcgkcQkMMENSvwF2ob0oqleZwnR9SEJ2VqDWIAiw24Z4HHdDWGtEp9YS9DdUtwtdNMFiPgg0U1CnBUkxIFOdrWRdCSACQaGoGYiP2ZJ8MkiMMnwff44t8mdTs9M9/S5fbv7vl5Vt+4933NO96dPnaTfc/p7zqdaawEAANbum8ZdAAAAbBXCNQAA9ES4BgCAngjXAADQE+EaAAB6IlwDAEBPjht3AX05+eST244dO8ZdBgAAW9ztt9/+v1trpyy3bsuE6x07dmRhYWHcZQAAsMVV1d8ebp1pIQAA0BPhGgAAeiJcAwBAT4RrAADoiXANAAA9Ea4BAKAnwjUAAPREuAYAgJ4I1wAA0BPhGgAAeiJcAwBAT4RrAADoiXANAAA9Ea4BAKAnwjUAAPREuAYAgJ4I1wAAbAyzs8k55yRPfnLy+Md374ufl75OOy255JJkfn7cVR/iuHEXAAAAmZ1NXvnKlW//4IPJjTcm73lPcsstyfT06GpbBVeuAQAYv+uvP7b9HnoomZvrtZS1EK4BABi/Sy89tv2OPz6Zmem1lLUYabiuqgur6u6q2ltVVy6z/qlV9cGq+khVfayqfmwwvqOqvlJVdwxe/22UdQIAMGa7diXXXJM885nJk56UPO5x3fvi56WvU09NLr54Q00JSZJqrY3mC1dtS/LJJM9Lsi/JbUle1Fq7a2ib2SQfaa39dlWdk+S9rbUdVbUjyR+31r57pd9vamqqLSws9PkjAADAo1TV7a21qeXWjfLK9blJ9rbW7mmtHUhybZKLlmzTkjx+8PkJSf5+hPUAAMBIjTJcn57k3qHlfYOxYb+c5Keqal+S9yZ51dC6swbTRW6pqh8eYZ0AANCLcd/Q+KIkb2+tnZHkx5L8XlV9U5LPJnlqa+3ZSf5tkt+vqscv3bmqdlXVQlUt7N+/f10LBwCApUb5nOv7kpw5tHzGYGzYy5NcmCSttfmqOjHJya21LyT52mD89qr6dJJnJDlkUnVrbTbJbNLNuR7FDwEwFrOzyRvekNx/f3cnfNI9bmqltto+6/39xr3PYx6TvOxlya/+6sq/1qLhc2eUNU7SPuv9/bbaPqvZ97GPTc47L7niig11k+JqjDJc35bk7Ko6K12ovizJTy7Z5u+S7Ezy9qp6ZpITk+yvqlOS3N9aO1hVT09ydpJ7RlgrwMax2kYKbD0PPpj82q91n1cTsJ07bHYbtDHMaoxsWkhr7eEklye5Kcknkvxha+3Oqrqqql4w2OwXkryiqj6a5F1JXta6x5ecn+RjVXVHkuuS/OvW2jL/BAfYgo61kQJbzw03rG575w5bxQZrDLMaI21/3lp7b7obFYfHfmno811JnrvMftcn8X8IYDJdemny/vePuwo2ghe+cHXbO3fYKjZYY5jVGGm4BuAY7NrVvZtzPb7vN+59jnXO9dJzZ5Q1TtI+6/39tto+q9l3C8y5HlkTmfWmiQwAAOthXE1kAABgogjXAADQE+EaAAB64oZGgJVYa1OXRSvddy1NRNj81tIIxrkDYyVcAxzNOBpzHGsTETa/tZ5vzh0YK9NCAI5mnI05VttEhM2vr/PNuQNjIVwDHM2ll47ve6+2iQibX1/nm3MHxsK0EICj6aOpyyJzrjmatTaCce7AWGkiAwAAq6CJDAAArAPhGgAAeiJcAwBAT4RrgKXm55NLLklOOy15/OO711Oekrz2teOuDIANztNCAIbNzyfnn588/PCh4xpzALACrlwDDJube3SwHqYxBwBHIFwDDJuZSY47wh/1NOYA4AiEa4Bh09PJrbcmF1+cnHpq8rjHda9v/dbkiitMCQHgiMy5Blhqejp597vHXQUAm5Ar1wAA0BPhGgAAeiJcAwBAT8y5ZmXm57tn/H7oQ8mXv3z47Y4/vnt/6KGVf+1R7/PkJyeve12ya9fKvz6jd7Rzapzn0vHHdzczvuY1zhsAVkW45ugO11Rjs3jwweSVr+w+C0obw2Y4p+6/33kDwKqZFsLRHa2pxmZx/fXjroBFm+mcct4AsArCNUd3tKYam8Wll467AhZtpnPKeQPAKmyS326M1WJTDXOu6ctKzilzrgHYhKq1Nu4aejE1NdUWFhbGXQYAAFtcVd3eWptabp1pIQAA0BPhGgAAeiJcAwBAT4RrAADoiaeFbBVLu9099rHJeeclV1zRPZkhSWZnkze9Kfn851f2NIXhpyhs5qcnvPa1ydvelnzta93yev4sS7/30WzEp62M6vtt5nMKAA7D00K2giN1uzv++OSWW5KPf/yRbnNrdc01mycMvfa13T86DmeUP8vRvjeP2EznFAATz9NCtrojdbt76KFufZ9d5jZTx7obbjjy+lH+LEf73jxiM51TAHAEwvVWcKRud8cf363vs8vcZupY98IXHnn9KH+Wo31vHrGZzikAOAJzrreC5brdLZ1zvTjvetLmXP/qr3bv45hzvdz3PhpzrgFgUzPnGgAAVsGcawAAWAfCNQAA9ES4BgCAnrihcauYne0eZ3bppd3NYcMNY1pLnva0ZMeO7gayl7zkkRscJ9V6NXdxwx4ATBQ3NG4Fs7OHNoh58YuTd77z8NufcELywQ9ObsAeR3MXTVIAYMtwQ+NWt7QBx5/8yZG3P3CgaywzqcbR3EWTFACYCML1VrC0AceP/uiRt9++vWssM6nG0dxFkxQAmAgjnXNdVRcm+c0k25K8pbX2xiXrn5rkd5M8cbDNla219w7WvS7Jy5McTPLq1tpNo6x1U1ucbjA85/r88825Ppz1bO5izjUATJSRzbmuqm1JPpnkeUn2JbktyYtaa3cNbTOb5COttd+uqnOSvLe1tmPw+V1Jzk3ybUn+NMkzWmsHD/f9JnrONQAA62Zcc67PTbK3tXZPa+1AkmuTXLRkm5bk8YPPT0jy94PPFyW5trX2tdbaZ5LsHXw9AADYsEYZrk9Pcu/Q8r7B2LBfTvJTVbUvyXuTvGoV+6aqdlXVQlUt7N+/v6+6AQDgmIz7hsYXJXl7a+2MJD+W5PeqasU1tdZmW2tTrbWpU045ZWRFAgDASozyhsb7kpw5tHzGYGzYy5NcmCSttfmqOjHJySvcl0Xz892j9WZmlr9RcX4+ecc7us+TfjMjAMAIjTJc35bk7Ko6K10wvizJTy7Z5u+S7Ezy9qp6ZpITk+xPsjvJ71fVr6e7ofHsJB8eYa2b1/x8snNn9+zq7duTPXsODc/z813oPnCgW/6d35nsBjIAACM0smkhrbWHk1ye5KYkn0jyh621O6vqqqp6wWCzX0jyiqr6aLqng7ysde5M8odJ7kryviQ/d6QnhUy0ubkuOB88uHxzmLm5Qx8fN+kNZAAARmikz7kePLP6vUvGfmno811JnnuYff9jkv84yvq2hJmZ7or14pXrpc1hZma65y0vXrme9AYyAAAjNNJwzTqYnu6mghxuzvX0dLfOnGsAgJEbWROZ9aaJDAAA62FcTWQAAGCiCNcAANAT4RoAAHrihsbNToMYAIANQ7jezDSIAQDYUEwL2cw0iAEA2FCE681ssUHMIg1iAADGyrSQzUyDGACADUW43uympwVqAIANwrQQAADoiXANAAA9Ea4BAKAnwvVmMD+fXH119z5sdjY555zku76r+wwAwFi5oXGjm59Pdu7snmG9fXuyZ093A+PsbPLKVz6y3eLnXbvGUycAAK5cb3hzc12wPnjw0CYx11//6G2XGwMAYN0I1xvdzEx3xXrbtkObxFx66aO3XW4MAIB1Y1rIRjc93U0FmZvrgvXiM60Xp3+86U1JVfKa15gSAgAwZtVaG3cNvZiammoLCwvjLgMAgC2uqm5vrU0tt860EAAA6IlwDQAAPRGuAQCgJ8I1AAD0RLjeyBY7MJ52Wvca7sR4uK6NAACMjUfxbVRLOzAmyec+1419+tPJf/2vj+7aCADAWLlyvVEdqdviDTcs37URAICxEq43qiN1W3zhC5fv2ggAwFiZFrJRDXdgfOCB7vOTnvRIJ8aLL35010YAAMZKh0YAAFgFHRoBAGAdCNcAANAT4RoAAHoiXG9kSxvFzM4mO3Ykj3988uQnH9pUBgCAsfO0kI1qfj7ZufORRjGvelXya7926Db33/9Io5nFp4sAADA2rlxvVHNzhzaKueGGw297pIYzAACsG+F6o5qZObRRzAtfePhtj9RwBgCAdWNayEY1PZ3s2XNoo5hv//bkDW/opoMcf3xy6qmPNJUBAGDsNJEBAIBV0EQGAADWgXANAAA9Ea4BAKAnwvVGNDubnHOOJjEAAJuMp4VsNLOzjzSGSTSJAQDYRFy53miWawijSQwAwKYw0nBdVRdW1d1Vtbeqrlxm/W9U1R2D1yer6ktD6w4Ords9yjo3lOUawmgSAwCwKYxsWkhVbUvy5iTPS7IvyW1Vtbu1dtfiNq21nx/a/lVJnj30Jb7SWnvWqOrbsBanf7zpTUmVJjEAAJvIKOdcn5tkb2vtniSpqmuTXJTkrsNs/6Ikrx9hPZvHrl0CNQDAJjTKaSGnJ7l3aHnfYOxRquppSc5K8oGh4ROraqGqPlRVF4+uTAAA6MdGeVrIZUmua60dHBp7Wmvtvqp6epIPVNXHW2ufHt6pqnYl2ZUkT33qU9evWgAAWMYor1zfl+TMoeUzBmPLuSzJu4YHWmv3Dd7vSTKXQ+djL24z21qbaq1NnXLKKX3UDAAAx2yU4fq2JGdX1VlVtT1dgH7UUz+q6juTnJRkfmjspKo6YfD55CTPzeHnam9Os7PJjh3JU56SPP/5XdOYJz85efzjk9NOSy65JJmfP+qXAQBg4xjZtJDW2sNVdXmSm5JsS/K21tqdVXVVkoXW2mLQvizJta21NrT7M5NcU1VfT/cPgDcOP2Vk01vaKOb97z90/YMPJjfemLznPckttyTT0+tbHwAAx2Skc65ba+9N8t4lY7+0ZPmXl9nvz5N8zyhrG6uVNoV56KFkbk64BgDYJHRoHIeVNoU5/vhkZmakpQAA0J+N8rSQybL4DOs3vCH5yleSZz0ruffe5POf765WP/axyXnnJVdc4ao1AMAmIlyPi0YxAABbjmkhAADQE+EaAAB6IlwDAEBPhOv1Mj/fNYY57bSuUcxZZ3XPu56dTZ7zHE1jAAC2ADc0rof5+eT885OHH35k7MEHD20kk2gaAwCwyblyvR7m5g4N1oez2DQGAIBNSbheDzMzyXEr+COBpjEAAJuacL0epqeTW29NLr44OfXU5HGPS3bsSK65pnude263zpQQAIBNrVpr466hF1NTU21hYWHcZQAAsMVV1e2ttanl1rlyDQAAPRGuAQCgJ8I1AAD0RLgGAICeaCIzavPz3bOrv/Sl5I47kksvTXbtGndVAACMgHA9SvPzyc6dyVe/miw+leX97+/eBWwAgC3HtJBRmptLDhx4JFgvuv76sZQDAMBoCdejNDOTbN+eVB06fumlYykHAIDRMi1klKankz17zLkGAJgQwvWoTU9raQ4AMCFMCwEAgJ4I1wAA0BPhGgAAeiJcj9r8fHLJJclznpPMzo67GgAARsgNjaM0P5+cf37y8MPd8oc/3L17WggAwJbkyvUozc09EqwXaSADALBlCdejNDOTHLfkjwMayAAAbFnC9ShNTye33ppcfHFy7rnJNdeYEgIAsIWZcz1q09PJu9897ioAAFgHrlwDAEBPhGsAAOiJcA0AAD0RrgEAoCfCNQAA9ES4BgCAngjXAADQE+EaAAB6IlwDAEBPhGsAAOiJcA0AAD0RrgEAoCfCNQAA9ES4BgCAnow0XFfVhVV1d1Xtraorl1n/G1V1x+D1yar60tC6l1bVpwavl46yTgAA6MNxo/rCVbUtyZuTPC/JviS3VdXu1tpdi9u01n5+aPtXJXn24POTkrw+yVSSluT2wb4PjKpeAABYq1FeuT43yd7W2j2ttQNJrk1y0RG2f1GSdw0+Pz/Jza21+weB+uYkF46wVgAAWLNRhuvTk9w7tLxvMPYoVfW0JGcl+cBq9wUAgI1io9zQeFmS61prB1ezU1XtqqqFqlrYv3//iEoDAICVGWW4vi/JmUPLZwzGlnNZHpkSsuJ9W2uzrbWp1trUKaecssZyAQBgbUYZrm9LcnZVnVVV29MF6N1LN6qq70xyUpL5oeGbklxQVSdV1UlJLhiMAQDAhjWyp4W01h6uqsvTheJtSd7WWruzqq5KstBaWwzalyW5trXWhva9v6p+JV1AT5KrWmv3j6rWkZifT97xjuRzn0tOPTV5yUuS6elxVwUAwAjVUKbd1KamptrCwsK4y+jMzyczM8mBA4+MnXBC8sEPCtgAAJtcVd3eWptabt1GuaFxa5mbSx566NCxAwe6cQAAtizhehRmZpLjjz90bPv2bhwAgC1rZHOuJ9r0dHeV2pxrAICJsqJwXVU3JHlrkj9prX19tCVtEdPTwjQAwIRZ6bSQ30ryk0k+VVVvrKrvGGFNAACwKa0oXLfW/rS19uIk35/kb5L8aVX9eVX9dFUdf+S9AQBgMqz4hsaqenKSlyX52SQfSfKb6cL2zSOpDAAANpmVzrl+d5LvSPJ7Sf6v1tpnB6v+oKo2yMOlAQBgvFb6tJD/0lr74HIrDvcAbdI1k5mb6x7B5+ZGAIAtb6Xh+pyq+khr7UtJUlUnJXlRa+23RlfaJjc/n+zc2TWP2b492bNHwAYA2OJWOuf6FYvBOklaaw8kecVoStoi5ua6YH3woO6MAAATYqXheltV1eJCVW1Lsn00JW0RMzPdFett23RnBACYECudFvK+dDcvXjNYfuVgjMOZnu6mgphzDQAwMVYarl+bLlD/m8HyzUneMpKKthJdGgEAJsqKwvWg5flvD14AAMAyVvqc67OTXJ3knCQnLo631p4+oroAAGDTWekNjb+T7qr1w0n+WZJ3JPl/R1UUAABsRisN149pre1JUq21v22t/XKSfzG6sraA+fnk6qu7dwAAJsJKb2j8WlV9U5JPVdXlSe5L8i2jK2uT00AGAGAirfTK9WuSfHOSVyf5gSQ/leSloypq09NABgBgIh31yvWgYcxPtNb+XZL/k+SnR17VZrfYQGbxyrUGMgAAE+Go4bq1drCqfmg9itkyNJABAJhIK51z/ZGq2p3kvyf58uJga+2GkVS1FWggAwAwcVYark9M8sUkPzI01pII1wAAMLDSDo3mWQMAwFGstEPj76S7Un2I1trP9F4RAABsUiudFvLHQ59PTHJJkr/vv5wtYH7ejYwAABNqpdNCrh9erqp3JflfI6loM9M8BgBgoq20icxSZyf51j4L2RI0jwEAmGgrnXP9YA6dc/25JK8dSUWbmeYxAAATbaXTQh436kK2BM1jAAAm2kqvXF+S5AOttX8YLD8xyUxr7cZRFrcpaR4DADCxVjrn+vWLwTpJWmtfSvL60ZQEAACb00rD9XLbrfQxfgAAMBFWGq4XqurXq+rbB69fT3L7KAsDAIDNZqXh+lVJDiT5gyTXJvlqkp8bVVGb3uxs8pznJJdc0j37GgCAibDSp4V8OcmVI65la5idTV75ykeW3/Oe5JZb3OQIADABVnTluqpuHjwhZHH5pKq6aXRlbWLXX3/o8kMPaSYDADAhVjot5OTBE0KSJK21B6JD4/IuvfTQ5eOP10wGAGBCrPSJH1+vqqe21v4uSapqRw7t2MiiXbu697e+Nfm2b0uuuMKUEACACbHScP2LSf5XVd2SpJL8cJJdI6tqs9u165GQDQDAxFjpDY3vq6qpdIH6I0luTPKVURYGAACbzUrbn/9sktckOSPJHUnOSzKf5EdGVxoAAGwuK72h8TVJfjDJ37bW/lmSZyf50pF3AQCAybLScP3V1tpXk6SqTmit/XWS7xhdWQAAsPmsNFzvGzzn+sYkN1fVHyX526PtVFUXVtXdVbW3qpZtQlNV/6qq7qqqO6vq94fGD1bVHYPX7hXWCQAAY7PSGxovGXz85ar6YJInJHnfkfapqm1J3pzkeUn2Jbmtqna31u4a2ubsJK9L8tzW2gNVNfzs7K+01p618h8FAADGa6WP4vuG1totK9z03CR7W2v3JElVXZvkoiR3DW3ziiRvHjSlSWvtC6utBwAANoqVTgs5FqcnuXdoed9gbNgzkjyjqv6sqj5UVRcOrTuxqhYG4xePsE4AAOjFqq9cj+D7n51kJt1j/m6tqu8ZtFp/Wmvtvqp6epIPVNXHW2ufHt65qnZl0MzmqU996vpWDgAAS4zyyvV9Sc4cWj5jMDZsX5LdrbWHWmufSfLJdGE7rbX7Bu/3JJlL9/i/Q7TWZltrU621qVNOOaX/nwAAAFZhlOH6tiRnV9VZVbU9yWVJlj7148Z0V61TVSenmyZyT1WdVFUnDI0/N4fO1QYAgA1nZNNCWmsPV9XlSW5Ksi3J21prd1bVVUkWWmu7B+suqKq7khxM8u9ba1+sqn+a5Jqq+nq6fwC8cfgpIwAAsBFVa23cNfRiamqqLSwsjLsMAAC2uKq6vbU2tdy6UU4LmUzz88nVV3fvAABMlHE/LWRrmZ9Pdu5MDhxItm9P9uxJpqfHXRUAAOvEles+zc11wfrgwe59bm7cFQEAsI6E6z7NzHRXrLdt695nZsZdEQAA68i0kD5NT3dTQebmumBtSggAwEQRrvs2PS1UAwBMKNNCAACgJ8I1AAD0RLgGAICeCNcAANAT4RoAAHoiXAMAQE+EawAA6IlwDQAAPRGuAQCgJ8I1AAD0RLgGAICeCNcAANAT4bpv8/PJ1Vd37wAATJTjxl3AljI/n+zcmRw4kGzfnuzZk0xPj7sqAADWiSvXfZqb64L1wYPd+9zcuCsCAGAdCdd9mpnprlhv29a9z8yMuyIAANaRaSF9mp7upoLMzXXB2pQQAICJIlz3bXpaqAYAmFCmhQAAQE+EawAA6IlwDQAAPRGu+6SBDADARHNDY180kAEAmHiuXPdFAxkAgIknXPdFAxkAgIlnWkhfNJABAJh4wnWfNJABAJhopoUAAEBPhGsAAOiJcA0AAD0RrgEAoCfCNQAA9ES4BgCAngjXAADQE+EaAAB6IlwDAEBPhGsAAOiJcA0AAD0RrgEAoCfCNQAA9GSk4bqqLqyqu6tqb1VdeZht/lVV3VVVd1bV7w+Nv7SqPjV4vXSUdfZifj65+uruHQCAiXTcqL5wVW1L8uYkz0uyL8ltVbW7tXbX0DZnJ3ldkue21h6oqm8djD8pyeuTTCVpSW4f7PvAqOpdk/n5ZOfO5MCBZPv2ZM+eZHp63FUBALDORnnl+twke1tr97TWDiS5NslFS7Z5RZI3L4bm1toXBuPPT3Jza+3+wbqbk1w4wlrXZm6uC9YHD3bvc3PjrggAgDEYZbg+Pcm9Q8v7BmPDnpHkGVX1Z1X1oaq6cBX7pqp2VdVCVS3s37+/x9JXaWamu2K9bVv3PjMzvloAABibkU0LWcX3PzvJTJIzktxaVd+z0p1ba7NJZpNkamqqjaLAFZme7qaCzM11wdqUEACAiTTKcH1fkjOHls8YjA3bl+QvWmsPJflMVX0yXdi+L13gHt53bmSV9mF6WqgGAJhwo5wWcluSs6vqrKranuSyJLuXbHNjBiG6qk5ON03kniQ3Jbmgqk6qqpOSXDAYAwCADWtkV65baw9X1eXpQvG2JG9rrd1ZVVclWWit7c4jIfquJAeT/PvW2heTpKp+JV1AT5KrWmv3j6pWAADoQ7U2vqnKfZqammoLCwvjLgMAgC2uqm5vrU0tt06Hxj5pJAMAMNHG/bSQrUMjGQCAiefKdV80kgEAmHjCdV80kgEAmHimhfRFIxkAgIknXPdJIxkAgIlmWggAAPREuAYAgJ4I1wAA0BPhGgAAeiJcAwBAT4RrAADoiXANAAA9Ea4BAKAnwjUAAPREuAYAgJ4I1wAA0BPhGgAAeiJcAwBAT4RrAADoiXANAAA9Ea4BAKAnwjUAAPREuAYAgJ4I1wAA0BPhGgAAeiJcAwBAT4RrAADoiXANAAA9Ea4BAKAnwjUAAPREuAYAgJ4I1wAA0BPhGgAAeiJcAwBAT4RrAADoiXDdl/n55Oqru3cAACbSceMuYEuYn0927kwOHEi2b0/27Emmp8ddFQAA68yV6z7MzXXB+uDB7n1ubtwVAQAwBsJ1H2ZmuivW27Z17zMz464IAIAxMC2kD9PT3VSQubkuWJsSAgAwkYTrvkxPC9UAABPOtBAAAOiJcA0AAD0RrgEAoCcjDddVdWFV3V1Ve6vqymXWv6yq9lfVHYPXzw6tOzg0vnuUdQIAQB9GdkNjVW1L8uYkz0uyL8ltVbW7tXbXkk3/oLV2+TJf4iuttWeNqj4AAOjbKK9cn5tkb2vtntbagSTXJrlohN8PAADGapTh+vQk9w4t7xuMLXVpVX2sqq6rqjOHxk+sqoWq+lBVXTzCOgEAoBfjvqHxfyTZ0Vr73iQ3J/ndoXVPa61NJfnJJG+qqm9funNV7RoE8IX9+/evT8UAAHAYowzX9yUZvhJ9xmDsG1prX2ytfW2w+JYkPzC07r7B+z1J5pI8e+k3aK3NttamWmtTp5xySr/VAwDAKo0yXN+W5OyqOquqtie5LMkhT/2oqtOGFl+Q5BOD8ZOq6oTB55OTPDfJ0hshAQBgQxnZ00Jaaw9X1eVJbkqyLcnbWmt3VtVVSRZaa7uTvLqqXpDk4ST3J3nZYPdnJrmmqr6e7h8Ab1zmKSMAALChVGtt3DX0Ympqqi0sLIy7DAAAtriqun1wb+CjjPuGRgAA2DKEawAA6IlwDQAAPRGuAQCgJ8I1AAD0RLgGAICeCNcAANAT4RoAAHoiXAMAQE+EawAA6IlwDQAAPRGuAQCgJ8I1AAD0RLgGAICeCNcAANAT4RoAAHoiXAMAQE+EawAA6IlwDQAAPRGu+zI/n1x9dfcOAMBEOm7cBWwJ859/gTsAAAxBSURBVPPJzp3JgQPJ9u3Jnj3J9PS4qwIAYJ25ct2HubkuWB882L3PzY27IgAAxkC47sPMTHfFetu27n1mZtwVAQAwBqaF9GF6upsKMjfXBWtTQgAAJpJw3ZfpaaEaAGDCmRYCAAA9Ea4BAKAnwjUAAPREuAYAgJ4I1wAA0BPhGgAAeiJcAwBAT4RrAADoiXANAAA9Ea4BAKAnwjUAAPREuAYAgJ4I1wAA0BPheq3m55NLLkme85xkdnbc1QAAMEbHjbuATW1+Pjn//OThh7vlD3+4e9+1a3w1AQAwNq5cr8Xc3CPBetH114+lFAAAxk+4XouZmeS4JRf/L710LKUAADB+wvVaTE8nt96aXHxxcu65yTXXmBICADDBzLleq+np5N3vHncVAABsAK5cAwBAT0Yarqvqwqq6u6r2VtWVy6x/WVXtr6o7Bq+fHVr30qr61OD10lHWCQAAfRjZtJCq2pbkzUmel2Rfktuqandr7a4lm/5Ba+3yJfs+Kcnrk0wlaUluH+z7wKjqBQCAtRrlletzk+xtrd3TWjuQ5NokF61w3+cnubm1dv8gUN+c5MIR1QkAAL0YZbg+Pcm9Q8v7BmNLXVpVH6uq66rqzFXuCwAAG8a4b2j8H0l2tNa+N93V6d9dzc5VtauqFqpqYf/+/SMpEAAAVmqU4fq+JGcOLZ8xGPuG1toXW2tfGyy+JckPrHTfwf6zrbWp1trUKaec0lvhAABwLEYZrm9LcnZVnVVV25NclmT38AZVddrQ4guSfGLw+aYkF1TVSVV1UpILBmMAALBhjexpIa21h6vq8nSheFuSt7XW7qyqq5IstNZ2J3l1Vb0gycNJ7k/yssG+91fVr6QL6ElyVWvt/lHVCgAAfajW2rhr6MXU1FRbWFgYdxkAAGxxVXV7a21quXXjvqERAAC2DOEaAAB6Ilyv1fx8cvXV3TsAABNtZDc0ToT5+WTnzuTAgWT79mTPnmR6etxVAQAwJq5cr8XcXBesDx7s3ufmxl0RAABjJFyvxcxMd8V627bufWZm3BUBADBGpoWsxfR0NxVkbq4L1qaEAABMNOF6raanhWoAAJKYFgIAAL0RrgEAoCfCNQAA9ES4BgCAngjXAADQE+EaAAB6IlwDAEBPhGsAAOiJcA0AAD0RrgEAoCfCNQAA9ES4BgCAngjXAADQE+EaAAB6IlwDAEBPhGsAAOhJtdbGXUMvqmp/kr8d07c/Ocn/HtP33iocw7VzDPvhOK6dY7h2juHaOYZr5xge3tNaa6cst2LLhOtxqqqF1trUuOvYzBzDtXMM++E4rp1juHaO4do5hmvnGB4b00IAAKAnwjUAAPREuO7H7LgL2AIcw7VzDPvhOK6dY7h2juHaOYZr5xgeA3OuAQCgJ65cAwBAT4TrNaiqC6vq7qraW1VXjruejaqqzqyqD1bVXVV1Z1W9ZjD+pKq6uao+NXg/aTBeVfVfBsf1Y1X1/eP9CTaOqtpWVR+pqj8eLJ9VVX8xOFZ/UFXbB+MnDJb3DtbvGGfdG0lVPbGqrquqv66qT1TVtHNxdarq5wf/Lf9VVb2rqk50Lh5dVb2tqr5QVX81NLbqc6+qXjrY/lNV9dJx/Czjcphj+J8G/z1/rKreXVVPHFr3usExvLuqnj80PrG/v5c7hkPrfqGqWlWdPFh2Hh4D4foYVdW2JG9O8qNJzknyoqo6Z7xVbVgPJ/mF1to5Sc5L8nODY3Vlkj2ttbOT7BksJ90xPXvw2pXkt9e/5A3rNUk+MbT8q0l+o7X2T5I8kOTlg/GXJ3lgMP4bg+3o/GaS97XWvjPJ96U7ns7FFaqq05O8OslUa+27k2xLclmciyvx9iQXLhlb1blXVU9K8vokz0lybpLXLwbyCfH2PPoY3pzku1tr35vkk0lelySD3zOXJfmuwT6/NbhAMem/v9+eRx/DVNWZSS5I8ndDw87DYyBcH7tzk+xtrd3TWjuQ5NokF425pg2ptfbZ1tpfDj4/mC7MnJ7ueP3uYLPfTXLx4PNFSd7ROh9K8sSqOm2dy95wquqMJP8iyVsGy5XkR5JcN9hk6TFcPLbXJdk52H6iVdUTkpyf5K1J0lo70Fr7UpyLq3VcksdU1XFJvjnJZ+NcPKrW2q1J7l8yvNpz7/lJbm6t3d9aeyBdsHxUUNqqljuGrbX3t9YeHix+KMkZg88XJbm2tfa11tpnkuxN97t7on9/H+Y8TLp//F6RZPhmPOfhMRCuj93pSe4dWt43GOMIBn8SfnaSv0jylNbaZwerPpfkKYPPju3y3pTuf3xfHyw/OcmXhn6pDB+nbxzDwfp/GGw/6c5Ksj/J7wym17ylqh4b5+KKtdbuS/Kf013d+my6c+v2OBeP1WrPPefkkf1Mkj8ZfHYMV6iqLkpyX2vto0tWOYbHQLhm3VTVtyS5Psn/3Vr7/4bXte6xNR5dcxhV9eNJvtBau33ctWxyxyX5/iS/3Vp7dpIv55E/wydxLh7N4E+/F6X7h8q3JXlsXLHqhXNvbarqF9NNQ3znuGvZTKrqm5P8hyS/NO5atgrh+tjdl+TMoeUzBmMso6qOTxes39lau2Ew/PnFP7EP3r8wGHdsH+25SV5QVX+T7k+YP5Ju7vATB3+aTw49Tt84hoP1T0jyxfUseIPal2Rfa+0vBsvXpQvbzsWV++dJPtNa299aeyjJDenOT+fisVntueecXEZVvSzJjyd5cXvkGcOO4cp8e7p/LH908DvmjCR/WVWnxjE8JsL1sbstydmDO+S3p7tpYveYa9qQBvMr35rkE621Xx9atTvJ4h3GL03yR0PjLxncpXxekn8Y+rPpRGqtva61dkZrbUe6c+0DrbUXJ/lgkn852GzpMVw8tv9ysP3EXxFrrX0uyb1V9R2DoZ1J7opzcTX+Lsl5VfXNg/+2F4+hc/HYrPbcuynJBVV10uCvCBcMxiZWVV2YbsrcC1pr/zi0aneSy6p7Ys1Z6W7K+3D8/j5Ea+3jrbVvba3tGPyO2Zfk+wf/v3QeHovWmtcxvpL8WLo7kz+d5BfHXc9GfSX5oXR/6vxYkjsGrx9LN+9yT5JPJfnTJE8abF/p7uT+dJKPp3sqwdh/jo3ySjKT5I8Hn5+e7pfF3iT/PckJg/ETB8t7B+ufPu66N8orybOSLAzOxxuTnORcXPUx/H+S/HWSv0rye0lOcC6u6Li9K9089YfSBZiXH8u5l25e8d7B66fH/XNtgGO4N93838XfL/9taPtfHBzDu5P86ND4xP7+Xu4YLln/N0lOdh4e+0uHRgAA6IlpIQAA0BPhGgAAeiJcAwBAT4RrAADoiXANAAA9Ea4BNriq+j+D9x1V9ZM9f+3/sGT5z/v8+gCTRrgG2Dx2JFlVuB7qmng4h4Tr1to/XWVNAAwRrgE2jzcm+eGquqOqfr6qtlXVf6qq26rqY1X1yiSpqpmq+p9VtTtd98RU1Y1VdXtV3VlVuwZjb0zymMHXe+dgbPEqeQ2+9l9V1cer6ieGvvZcVV1XVX9dVe8cdGpMVb2xqu4a1PKf1/3oAGwAR7uiAcDGcWWSf9da+/EkGYTkf2it/WBVnZDkz6rq/YNtvz/Jd7fWPjNY/pnW2v1V9Zgkt1XV9a21K6vq8tbas5b5Xi9M183y+5KcPNjn1sG6Zyf5riR/n+TPkjy3qj6R5JIk39laa1X1xN5/eoBNwJVrgM3rgiQvqao7kvxFulbaZw/WfXgoWCfJq6vqo0k+lOTMoe0O54eSvKu1drC19vkktyT5waGvva+19vV07aZ3JPmHJF9N8taqemGSf1zzTwewCQnXAJtXJXlVa+1Zg9dZrbXFK9df/sZGVTNJ/nmS6dba9yX5SJIT1/B9vzb0+WCS41prDyc5N8l1SX48yfvW8PUBNi3hGmDzeDDJ44aWb0ryb6rq+CSpqmdU1WOX2e8JSR5orf1jVX1nkvOG1j20uP8S/zPJTwzmdZ+S5PwkHz5cYVX1LUme0Fp7b5KfTzedBGDimHMNsHl8LMnBwfSOtyf5zXRTMv5ycFPh/iQXL7Pf+5L868G86LvTTQ1ZNJvkY1X1l621Fw+NvzvJdJKPJmlJrmitfW4QzpfzuCR/VFUnprui/m+P7UcE2NyqtTbuGgAAYEswLQQAAHoiXAMAQE+EawAA6IlwDQAAPRGuAQCgJ8I1AAD0RLgGAICeCNcAANCT/x+C3M1Gtky4+AAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Uwd-NtlCfeEW"
      },
      "source": [
        "# **5. Write down the final training accuracy [5pt]**\n",
        "\n",
        "- present the final training accuracy in number (%) at convergence\n",
        "- the score will be given depending on the accuracy"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7zh6drNAf9QH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "f7d1df23-6047-44cf-b6ec-7b1070f02acd"
      },
      "source": [
        "print(\"Train Accuracy:  \", end=' ')\n",
        "print(accuracy_history[-1]*100, end='%')"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Train Accuracy:   85.59322033898306%"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "hh89M_mHfhIj"
      },
      "source": [
        "# **6. Plot the optimal classifier superimposed on the training data [5pt]**\n",
        "\n",
        "- plot the boundary of the optimal classifier at convergence (in green color)\n",
        "- the boundary of the classifier is defined by {(x,y)∣σ(g(x,y;θ))=0.5}={(x,y)∣g(x,y;θ)=0}\n",
        "- plot the training data points (x,y) with their labels lll in colors superimposed on the illustration of the classifier (blue for label 0 and red for label 1)\n",
        "- you can use contour function in python3\n",
        "- the score will be given depending on the accuracy"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IeaxofKzgwxd",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 301
        },
        "outputId": "d546de8a-8026-4ccb-9af8-ee6848d49a63"
      },
      "source": [
        "plotBoundary(theta, X_reg, y)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}