7.Logistic regression with Regularization.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Logistic regression with Regularization.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sQy9EvTe1J6q",
        "colab_type": "text"
      },
      "source": [
        "### **Preparation**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YgZQmLLx1HWI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import copy\n",
        "import math\n",
        "import csv\n",
        "from collections import deque\n",
        "from google.colab import files"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oDTD9ppr1OAX",
        "colab_type": "text"
      },
      "source": [
        "### **Input Data**\n",
        "load the training data file\n",
        "each row $\\{ (x^{(i)}, y^{(i)}, l^{(i)}) \\}$ of the data consists of a 2-dimensional point $(x, y)$ with its label $l$  \n",
        "$x, y \\in \\mathbb{R}$ and $l \\in \\{0, 1\\}$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XjbPUG9E1Tie",
        "colab_type": "code",
        "outputId": "4c1cd239-49b1-459a-c4dd-76926eeed029",
        "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": 78
        }
      },
      "source": [
        "uploaded = files.upload()"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-27b65ccc-e560-42de-838f-21089242a192\" name=\"files[]\" multiple disabled />\n",
              "     <output id=\"result-27b65ccc-e560-42de-838f-21089242a192\">\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": "code",
      "metadata": {
        "id": "MFaPtak-zpwW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "data = np.genfromtxt(\"data-nonlinear.txt\", delimiter=',')\n",
        "x = data[:, 0]\n",
        "y = data[:, 1]\n",
        "label = data[:, 2]\n",
        "x_label0 = x[label == 0]\n",
        "x_label1 = x[label == 1]\n",
        "y_label0 = y[label == 0]\n",
        "y_label1 = y[label == 1]\n",
        "\n",
        "iters = deque()\n",
        "accuracys1 = deque()\n",
        "accuracys2 = deque()\n",
        "accuracys3 = deque()\n",
        "accuracys4 = deque()\n",
        "accuracys5 = deque()\n",
        "train_costs1 = deque()\n",
        "train_costs2 = deque()\n",
        "train_costs3 = deque()\n",
        "train_costs4 = deque()\n",
        "train_costs5 = deque()\n",
        "theta_datas1 = deque()\n",
        "theta_datas2 = deque()\n",
        "theta_datas3 = deque()\n",
        "theta_datas4 = deque()\n",
        "theta_datas5 = deque()\n",
        "lambda_datas = deque()\n",
        "#print(label[57])\n",
        "#print(label[58])\n",
        "#print(type(x))\n",
        "#print(y_label0)\n",
        "#print(type(x_label0))\n",
        "#print(len(x)) #118\n",
        "#print(y)\n",
        "#print(label)\n",
        "#print(len(x_label0)) #60\n",
        "#print(len(x_label1)) #58"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cw4DKfx74hAg",
        "colab_type": "text"
      },
      "source": [
        "### **Logistic Regression**\n",
        "1) non-Linear Model\n",
        "<br>\n",
        "$\\ z =  g(x, y; \\theta) = \\sum_{i=0}^{9} \\sum_{j=0}^{9} \\theta_{i,j} x^{i} y^{j}$  \n",
        "$\\sigma(z) = \\frac{1}{1 + \\exp(-z)}$\n",
        "<br>  \n",
        "2) Objective Function\n",
        "<br>\n",
        "$J(\\theta) = \\frac{1}{m} \\sum_{i=1}^m \\left[ - l^{(i)} \\log(\\sigma(g(x^{(i)}, y^{(i)}; \\theta))) - (1 - l^{(i)}) \\log(1 - \\sigma(g(x^{(i)}, y^{(i)}; \\theta))) \\right] + \\frac{\\lambda}{2} \\sum_{i=0}^{9} \\sum_{j=0}^{9} \\theta_{i,j}^2$\n",
        "<br>  \n",
        "3) Gradient Descent\n",
        "<br>\n",
        "$\\theta_{i, j}^{(t+1)} = \\theta_{i, j}^{(t)} - \\alpha \\left[ \\frac{1}{m} \\sum_{i=1}^{m} (\\sigma(g(x^{(i)}, y^{(i)}; \\theta^{(t)})) - l^{(i)}) \\frac{\\partial g(x^{(i)}, y^{(i)}; \\theta^{(t)})}{\\partial \\theta_{i, j}} + \\lambda \\theta_{i, j}^{(t)} \\right]$, for all $i, j$  \n",
        "<br>\n",
        "4) HyperParameters Setting\n",
        "<br>\n",
        "$\\ lr = 1*10^{-3}$\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b8ZdZ71zkyiN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def sigmoidFunction(z):\n",
        "  result = 1/(1 + np.exp(-z))\n",
        "  return result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iPhWp_3TE3Uk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def gFunction(x_data, y_data, theta_data):  #단일 x,y와 모든 theta 계산\n",
        "  result = 0\n",
        "  for i in range(0, 10):\n",
        "    for j in range(0, 10):\n",
        "      result += theta_data[i][j] * np.power(x_data, i) * np.power(y_data, j)\n",
        "  return result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B-ZACWZb_njd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def objectiveFunction(x_data, y_data, class_data, theta_data, lambda_data):\n",
        "  cost = 0\n",
        "  predictions = deque()\n",
        "  for i in range(0, 118):\n",
        "    estimate = gFunction(x_data[i], y_data[i], theta_data)\n",
        "    estimate = sigmoidFunction(estimate)\n",
        "    #print(estimate)\n",
        "    #print(\"Estimate\",estimate)\n",
        "    predictions.append((-class_data[i]*np.log(estimate)) - (1-class_data[i])*np.log(1-estimate))\n",
        "    #print(\"predictions\",predictions)\n",
        "  cost = np.sum(predictions) / 118                          #data fidelity term\n",
        "  cost += lambda_data / 2 * np.sum(np.square(theta_data))   #regularization term\n",
        "  #print(\"Cost출력\",cost)\n",
        "  return cost"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NsaVBnlHiAys",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def gradientDescent(x_data, y_data, class_data, theta_data, lambda_data):\n",
        "  lr = 3e-1\n",
        "  for i in range(0, 10):\n",
        "    for j in range(0, 10):\n",
        "      estimate = 0\n",
        "      for k in range(0, 118):\n",
        "        estimate += (sigmoidFunction(gFunction(x_data[k], y_data[k], theta_data)) - class_data[k]) * np.power(x_data[k],i) * np.power(y_data[k],j)\n",
        "      theta_data[i][j] -= lr * (estimate/118 + lambda_data * theta_data[i][j])\n",
        "  return theta_data"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nKROWnxQlgsK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def main():\n",
        "  theta_data = np.zeros([10,10])  #Initialization\n",
        "  \n",
        "  for iter in range(0, 250):    \n",
        "    lambda_data = 0.00001\n",
        "    train_value = objectiveFunction(x, y, label, theta_data, lambda_data)\n",
        "    train_costs1.append(train_value)\n",
        "    theta_data = gradientDescent(x, y, label, theta_data, lambda_data)\n",
        "    check = 0\n",
        "    for i in range(0, 60):\n",
        "      if gFunction(x[i], y[i], theta_data) >= 0:\n",
        "        check += 1\n",
        "    for i in range(60, 118):\n",
        "      if gFunction(x[i], y[i], theta_data)  < 0:\n",
        "        check += 1\n",
        "    accuracy = check / 118 * 100\n",
        "    accuracys1.append(accuracy)\n",
        "    iters.append(iter)\n",
        "    theta_datas1.append(theta_data)\n",
        "    lambda_datas.append(lambda_data)\n",
        "\n",
        "  ## 2번째 람다 실험\n",
        "  theta_data = np.zeros([10,10])  #Initialization\n",
        "  for iter in range(0, 250):    \n",
        "    check = 0\n",
        "    for i in range(0, 60):\n",
        "      if gFunction(x[i], y[i], theta_data) >= 0:\n",
        "        check += 1\n",
        "    for i in range(60, 118):\n",
        "      if gFunction(x[i], y[i], theta_data)  < 0:\n",
        "        check += 1\n",
        "    accuracy = check / 118 * 100\n",
        "    accuracys2.append(accuracy)\n",
        "\n",
        "    lambda_data = 0.01\n",
        "    train_value = objectiveFunction(x, y, label, theta_data, lambda_data)\n",
        "    train_costs2.append(train_value)\n",
        "    theta_data = gradientDescent(x, y, label, theta_data, lambda_data)\n",
        "    theta_datas2.append(theta_data)\n",
        "    lambda_datas.append(lambda_data)\n",
        "\n",
        "  ## 3번째 람다 실험\n",
        "  theta_data = np.zeros([10,10])  #Initialization\n",
        "  for iter in range(0, 250):    \n",
        "    check = 0\n",
        "    for i in range(0, 60):\n",
        "      if gFunction(x[i], y[i], theta_data) >= 0:\n",
        "        check += 1\n",
        "    for i in range(60, 118):\n",
        "      if gFunction(x[i], y[i], theta_data)  < 0:\n",
        "        check += 1\n",
        "    accuracy = check / 118 * 100\n",
        "    accuracys3.append(accuracy)\n",
        "\n",
        "    lambda_data = 1\n",
        "    train_value = objectiveFunction(x, y, label, theta_data, lambda_data)\n",
        "    train_costs3.append(train_value)\n",
        "    theta_data = gradientDescent(x, y, label, theta_data, lambda_data)\n",
        "    theta_datas3.append(theta_data)\n",
        "    lambda_datas.append(lambda_data)\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "  main()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FvYhujX-JNLK",
        "colab_type": "text"
      },
      "source": [
        "### **1. Plot the training data**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T8fDzM1DJH53",
        "colab_type": "code",
        "outputId": "9143c7f0-2192-4b82-d0c1-1ea93e2f94c7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        }
      },
      "source": [
        "print(\"Plotting the training data\")\n",
        "plt.figure()\n",
        "plt.scatter(x_label0, y_label0, alpha=0.3, c='b')\n",
        "plt.scatter(x_label1, y_label1, alpha=0.3, c='r')\n",
        "plt.show()"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Plotting the training data\n"
          ],
          "name": "stdout"
        },
        {
          "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": {
        "id": "D4-SO5AfK4Qe",
        "colab_type": "text"
      },
      "source": [
        "### **2. Plotting the Training Error with Regularizations**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xpmo7Xr-LKzC",
        "colab_type": "code",
        "outputId": "8c36a646-44f7-4838-cc3a-3a5c0ce60b95",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        }
      },
      "source": [
        "print(\"Plotting the Training Error\")\n",
        "plt.plot(iters, train_costs1, 'r')\n",
        "plt.plot(iters, train_costs2, 'g')\n",
        "plt.plot(iters, train_costs3, 'b')\n",
        "plt.xlabel('iteration')\n",
        "plt.ylabel('Traing Error')\n",
        "plt.show()"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Plotting the Training Error\n"
          ],
          "name": "stdout"
        },
        {
          "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": {
        "id": "2skLDWZvqpQq",
        "colab_type": "text"
      },
      "source": [
        "### **3. Displaying the values of the chosen Regularizations**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KaC5-xyyq1dC",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "outputId": "fd11eda3-f211-4ea2-ec3f-15839fc3ab19"
      },
      "source": [
        "lambda1 = lambda_datas[0]\n",
        "lambda2 = lambda_datas[1]\n",
        "lambda3 = lambda_datas[2]\n",
        "print(\"lambda1 :\\033[31m\",lambda1,\"\\033[0m\")\n",
        "print(\"lambda2 :\\033[32m\",lambda2,\"\\033[0m\")\n",
        "print(\"lambda3 :\\033[34m\",lambda3,\"\\033[0m\")"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "lambda1 :\u001b[31m 1e-05 \u001b[0m\n",
            "lambda2 :\u001b[32m 1e-02 \u001b[0m\n",
            "lambda3 :\u001b[34m 1 \u001b[0m\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oX0DzAdQLpGD",
        "colab_type": "text"
      },
      "source": [
        "### **4. Plotting the Training Accuracy with Regularizations**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_tI6dv4cLmDQ",
        "colab_type": "code",
        "outputId": "15e8db4f-f1ee-4e90-f55b-6b0543fce51f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        }
      },
      "source": [
        "print(\"Plotting the Training Accuracy\")\n",
        "plt.plot(iters, accuracys1, 'r')\n",
        "plt.plot(iters, accuracys2, 'g')\n",
        "plt.plot(iters, accuracys3, 'b')\n",
        "plt.xlabel('iteration')\n",
        "plt.ylabel('Training Accuracy')\n",
        "plt.show()"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Plotting the Training Accuracy\n"
          ],
          "name": "stdout"
        },
        {
          "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": {
        "id": "zaf0tCc4L6q2",
        "colab_type": "text"
      },
      "source": [
        "### **5. Final Training Accuracy with Regularizations**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DVRpopvuL-G3",
        "colab_type": "code",
        "outputId": "3c9e3c24-0bb0-426f-c2c1-5fd51b073db7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        }
      },
      "source": [
        "print(\"Final Training Accuracy :\\033[31m\",accuracys1[-1],\"% \\033[0m\")\n",
        "print(\"Final Training Accuracy :\\033[32m\",accuracys2[-1],\"% \\033[0m\")\n",
        "print(\"Final Training Accuracy :\\033[34m\",accuracys3[-1],\"% \\033[0m\")"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Final Training Accuracy :\u001b[31m 82.20338983050848 % \u001b[0m\n",
            "Final Training Accuracy :\u001b[32m 81.35593220338984 % \u001b[0m\n",
            "Final Training Accuracy :\u001b[34m 60.16949152542372 % \u001b[0m\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w9rPVPoMMGJH",
        "colab_type": "text"
      },
      "source": [
        "### **6. Plotting the Optimal Classifer superimposed on the Training Data**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Qda9OL1AlZV",
        "colab_type": "code",
        "outputId": "771acfee-e9f7-443c-facc-8c0ef4ac0df8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        }
      },
      "source": [
        "theta_1 = theta_datas1[-1]\n",
        "theta_2 = theta_datas2[-1]\n",
        "theta_3 = theta_datas3[-1]\n",
        "\n",
        "Xmesh, Ymesh = np.meshgrid(np.linspace(-1.0, 1.0, 300), np.linspace(-1.0, 1.0, 300))\n",
        "\n",
        "Z1 = gFunction(Xmesh, Ymesh, theta_1)\n",
        "Z2 = gFunction(Xmesh, Ymesh, theta_2)\n",
        "Z3 = gFunction(Xmesh, Ymesh, theta_3)\n",
        "\n",
        "fig = plt.figure()\n",
        "levels = [0]\n",
        "graph1 = plt.contour(Xmesh, Ymesh, Z1, levels, colors = 'red')\n",
        "graph2 = plt.contour(Xmesh, Ymesh, Z2, levels, colors = 'green')\n",
        "graph3 = plt.contour(Xmesh, Ymesh, Z3, levels, colors = 'blue')\n",
        "graph4 = plt.scatter(x_label0, y_label0, alpha=0.3, c='b')\n",
        "graph5 = plt.scatter(x_label1, y_label1, alpha=0.3, c='r')\n",
        "plt.show()"
      ],
      "execution_count": 15,
      "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"
          }
        }
      ]
    }
  ]
}