LFD Problem 1.5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generate a training data set of size 100 similar to that used in Exercise 1 .4. Generate a test data set of size 10, 000 from the same process. To get g, run the algorithm above with n = 100 on the training data set, until a maximum of 1, 000 updates has been reached . Plot the training data set, the target function f, and the final hypothesis g on the same figure. Report the error on the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No.of iterations= 1000\n",
      "[-51.         -78.97102252 -27.06937054]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 480x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.rcParams['axes.unicode_minus'] = False \n",
    "\n",
    "#generate a data set of 100. \n",
    "#for simplicity, 50 in the first quadrant, another 50 in the third quadrant \n",
    "\n",
    "def generate_points(N):\n",
    "    X1 = []\n",
    "    Y1 = []\n",
    "    X2 = []\n",
    "    Y2 = []\n",
    "\n",
    "    for i in range(N):\n",
    "        X1.append(random.uniform(0,1))\n",
    "        Y1.append(random.uniform(0,1))\n",
    "        X2.append(random.uniform(-1,0))\n",
    "        Y2.append(random.uniform(-1,0))\n",
    "        \n",
    "    #label the data\n",
    "    data1 = [np.array([1,X1[i],Y1[i],1]) for i in range(50)]\n",
    "    data2 = [np.array([1,X2[i],Y2[i],-1]) for i in range(50)]\n",
    "    data = data1 + data2\n",
    "    \n",
    "    return data\n",
    " \n",
    "    \n",
    "\n",
    "X = []\n",
    "\n",
    "Y = []\n",
    "\n",
    "for i in range(100):\n",
    "    Y.append(data[i][3])\n",
    "#print(Y)\n",
    "\n",
    "for i in range(100):\n",
    "    X.append(data[i][:3])\n",
    "    \n",
    "    \n",
    "#The perceptron algorithm to find the weight and calculate exact target function\n",
    "def Perceptron(X, Y):\n",
    "\n",
    "    weights = [0,0,0]\n",
    "    n = 100\n",
    "    epoch = 10\n",
    "    iteration = 0\n",
    "\n",
    "    for k in range(epoch):\n",
    "        for i, n in enumerate(X):\n",
    "            predicted_y = np.sign(np.dot(np.transpose(weights), X[i]))    # y' = w^T *X  \n",
    "            actual_y = Y[i]\n",
    "            if (predicted_y * actual_y) >1:\n",
    "                weights = weights\n",
    "            else:\n",
    "                iteration = iteration + 1\n",
    "                weights = weights + n*(actual_y-predicted_y)*X[i]\n",
    "                   \n",
    "    print(\"No.of iterations= \" + str(iteration) )\n",
    "    return weights\n",
    "\n",
    "\n",
    "z = Perceptron(X,Y)\n",
    "print(z)\n",
    "\n",
    "w0 = z[0]\n",
    "w1 = z[1]\n",
    "w2 = z[2]\n",
    "\n",
    "slope = -w1/w2\n",
    "intercept = -w0/w2\n",
    "\n",
    "generate_points(N=100)\n",
    "\n",
    "plt.figure(figsize=(8,6), dpi=60)\n",
    "\n",
    "def abline(slope, intercept):\n",
    "     # Plot a line from slope and intercept\n",
    "     ax = plt.gca()\n",
    "     x_value = np.array(ax.get_xlim())\n",
    "     y_value = intercept + slope * x_value\n",
    "     plt.plot(x_value, y_value, '--')\n",
    "\n",
    "abline(slope,intercept)  \n",
    "\n",
    "def plot_points(data):\n",
    "\n",
    "    for i in range(100):\n",
    "        if (data[i][3] == 1):\n",
    "            plt.plot(data[i][1], data[i][2], 'ro')\n",
    "        elif (data[i][3] ==-1):\n",
    "            plt.plot (data[i][1], data[i][2], 'bo')\n",
    "        \n",
    "    plt.xlabel('X')\n",
    "    plt.ylabel('Y') \n",
    "        \n",
    "    plt.plot([-1,1], [1,-1], 'r-')\n",
    "    \n",
    "    \n",
    "plot_points(data)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Testing it for a dataset of 10,000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No.of iterations= 100000\n",
      "There are 5000 misclassfied points\n",
      "Errored value 50.0%\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.rcParams['axes.unicode_minus'] = False \n",
    "\n",
    "#generate a data set of 10000. \n",
    "#for simplicity, 5000 in the first quadrant, another 5000 in the third quadrant \n",
    "\n",
    "X1 = []\n",
    "Y1 = []\n",
    "X2 = []\n",
    "Y2 = []\n",
    "\n",
    "for i in range(5000):\n",
    "    X1.append(random.uniform(0,1))\n",
    "    Y1.append(random.uniform(0,1))\n",
    "    X2.append(random.uniform(-1,0))\n",
    "    Y2.append(random.uniform(-1,0))\n",
    "\n",
    "#label the data\n",
    "data1 = [np.array([1,X1[i],Y1[i],1]) for i in range(5000)]\n",
    "data2 = [np.array([1,X2[i],Y2[i],-1]) for i in range(5000)]\n",
    "data = data1 + data2\n",
    "\n",
    "#plt.figure(figsize=(8,8), dpi=100)\n",
    "\n",
    "X = []\n",
    "\n",
    "Y = []\n",
    "\n",
    "for i in range(10000):\n",
    "    Y.append(data[i][3])\n",
    "#print(Y)\n",
    "\n",
    "for i in range(10000):\n",
    "    X.append(data[i][:3])\n",
    "\n",
    "    \n",
    "N = 10000\n",
    "\n",
    "#The perceptron algorithm to find the weight and calculate exact target function\n",
    "def Predict(X, Y):\n",
    "    \n",
    "    misclass = 0\n",
    "    classified = 0\n",
    "    new_weights = Perceptron(X,Y)              # getting the hypothesis from training data set \n",
    "       \n",
    "    for i, n in enumerate(X):\n",
    "        predicted_y = np.sign(np.dot(np.transpose(new_weights), X[i]))    # y' = w^T *X  \n",
    "        actual_y = Y[i]\n",
    "        if predicted_y != actual_y:\n",
    "      \n",
    "             misclass += 1\n",
    "                \n",
    "    print(\"There are \" + str(misclass) + \" misclassfied points\")\n",
    "    return (misclass)\n",
    "\n",
    "\n",
    "misclassified = Predict(X,Y)\n",
    "\n",
    "def error_calc(misclassified, N):\n",
    "    errored_value = (misclassified/N)*100\n",
    "    print(\"Errored value \"+ str(errored_value)+\"%\")\n",
    "\n",
    "error_calc(misclassified, N)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1.5 (b) Use the data set in ( a ) and redo everything with n = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No.of iterations= 1000\n",
      "[1.         0.03838749 0.35003446]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 480x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.rcParams['axes.unicode_minus'] = False \n",
    "\n",
    "#generate a data set of 100. \n",
    "#for simplicity, 50 in the first quadrant, another 50 in the third quadrant \n",
    "\n",
    "def generate_points(N):\n",
    "    X1 = []\n",
    "    Y1 = []\n",
    "    X2 = []\n",
    "    Y2 = []\n",
    "\n",
    "    for i in range(N):\n",
    "        X1.append(random.uniform(0,1))\n",
    "        Y1.append(random.uniform(0,1))\n",
    "        X2.append(random.uniform(-1,0))\n",
    "        Y2.append(random.uniform(-1,0))\n",
    "        \n",
    "    #label the data\n",
    "    data1 = [np.array([1,X1[i],Y1[i],1]) for i in range(50)]\n",
    "    data2 = [np.array([1,X2[i],Y2[i],-1]) for i in range(50)]\n",
    "    data = data1 + data2\n",
    "    \n",
    "    return data\n",
    " \n",
    "    \n",
    "\n",
    "X = []\n",
    "\n",
    "Y = []\n",
    "\n",
    "for i in range(100):\n",
    "    Y.append(data[i][3])\n",
    "#print(Y)\n",
    "\n",
    "for i in range(100):\n",
    "    X.append(data[i][:3])\n",
    "    \n",
    "    \n",
    "#The perceptron algorithm to find the weight and calculate exact target function\n",
    "def Perceptron(X, Y):\n",
    "\n",
    "    weights = [0,0,0]\n",
    "    n = 1\n",
    "    epoch = 10\n",
    "    iteration = 0\n",
    "\n",
    "    for k in range(epoch):\n",
    "        for i, n in enumerate(X):\n",
    "            predicted_y = np.sign(np.dot(np.transpose(weights), X[i]))    # y' = w^T *X  \n",
    "            actual_y = Y[i]\n",
    "            if (predicted_y * actual_y) >1:\n",
    "                weights = weights\n",
    "            else:\n",
    "                iteration = iteration + 1\n",
    "                weights = weights + n*(actual_y-predicted_y)*X[i]\n",
    "                   \n",
    "    print(\"No.of iterations= \" + str(iteration) )\n",
    "    return weights\n",
    "\n",
    "\n",
    "z = Perceptron(X,Y)\n",
    "print(z)\n",
    "\n",
    "w0 = z[0]\n",
    "w1 = z[1]\n",
    "w2 = z[2]\n",
    "\n",
    "slope = -w1/w2\n",
    "intercept = -w0/w2\n",
    "\n",
    "generate_points(N=100)\n",
    "\n",
    "plt.figure(figsize=(8,6), dpi=60)\n",
    "\n",
    "def abline(slope, intercept):\n",
    "     # Plot a line from slope and intercept\n",
    "     ax = plt.gca()\n",
    "     x_value = np.array(ax.get_xlim())\n",
    "     y_value = intercept + slope * x_value\n",
    "     plt.plot(x_value, y_value, '--')\n",
    "\n",
    "abline(slope,intercept)  \n",
    "\n",
    "def plot_points(data):\n",
    "\n",
    "    for i in range(100):\n",
    "        if (data[i][3] == 1):\n",
    "            plt.plot(data[i][1], data[i][2], 'ro')\n",
    "        elif (data[i][3] ==-1):\n",
    "            plt.plot (data[i][1], data[i][2], 'bo')\n",
    "        \n",
    "    plt.xlabel('X')\n",
    "    plt.ylabel('Y') \n",
    "        \n",
    "    plt.plot([-1,1], [1,-1], 'r-')\n",
    "    \n",
    "    \n",
    "plot_points(data)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No.of iterations= 100000\n",
      "There are 7079 misclassfied points\n",
      "Errored value 70.78999999999999%\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.rcParams['axes.unicode_minus'] = False \n",
    "\n",
    "#generate a data set of 10000. \n",
    "#for simplicity, 5000 in the first quadrant, another 5000 in the third quadrant \n",
    "\n",
    "X1 = []\n",
    "Y1 = []\n",
    "X2 = []\n",
    "Y2 = []\n",
    "\n",
    "for i in range(5000):\n",
    "    X1.append(random.uniform(0,1))\n",
    "    Y1.append(random.uniform(0,1))\n",
    "    X2.append(random.uniform(-1,0))\n",
    "    Y2.append(random.uniform(-1,0))\n",
    "\n",
    "#label the data\n",
    "data1 = [np.array([1,X1[i],Y1[i],1]) for i in range(5000)]\n",
    "data2 = [np.array([1,X2[i],Y2[i],-1]) for i in range(5000)]\n",
    "data = data1 + data2\n",
    "\n",
    "#plt.figure(figsize=(8,8), dpi=100)\n",
    "\n",
    "X = []\n",
    "\n",
    "Y = []\n",
    "\n",
    "for i in range(10000):\n",
    "    Y.append(data[i][3])\n",
    "#print(Y)\n",
    "\n",
    "for i in range(10000):\n",
    "    X.append(data[i][:3])\n",
    "\n",
    "    \n",
    "N = 10000\n",
    "\n",
    "#The perceptron algorithm to find the weight and calculate exact target function\n",
    "def Predict(X, Y):\n",
    "    \n",
    "    misclass = 0\n",
    "    classified = 0\n",
    "    new_weights = Perceptron(X,Y)              # getting the hypothesis from training data set \n",
    "       \n",
    "    for i, n in enumerate(X):\n",
    "        predicted_y = np.sign(np.dot(np.transpose(new_weights), X[i]))    # y' = w^T *X  \n",
    "        actual_y = Y[i]\n",
    "        if predicted_y != actual_y:\n",
    "      \n",
    "             misclass += 1\n",
    "                \n",
    "    print(\"There are \" + str(misclass) + \" misclassfied points\")\n",
    "    return (misclass)\n",
    "\n",
    "\n",
    "misclassified = Predict(X,Y)\n",
    "\n",
    "def error_calc(misclassified, N):\n",
    "    errored_value = (misclassified/N)*100\n",
    "    print(\"Errored value \"+ str(errored_value)+\"%\")\n",
    "\n",
    "error_calc(misclassified, N)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.5 ( c ) Use the data set in (a) and redo everything with n = 0 . 01 ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No.of iterations= 1000\n",
      "[1.         0.15023378 0.03569212]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 480x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.rcParams['axes.unicode_minus'] = False \n",
    "\n",
    "#generate a data set of 100. \n",
    "#for simplicity, 50 in the first quadrant, another 50 in the third quadrant \n",
    "\n",
    "def generate_points(N):\n",
    "    X1 = []\n",
    "    Y1 = []\n",
    "    X2 = []\n",
    "    Y2 = []\n",
    "\n",
    "    for i in range(N):\n",
    "        X1.append(random.uniform(0,1))\n",
    "        Y1.append(random.uniform(0,1))\n",
    "        X2.append(random.uniform(-1,0))\n",
    "        Y2.append(random.uniform(-1,0))\n",
    "        \n",
    "    #label the data\n",
    "    data1 = [np.array([1,X1[i],Y1[i],1]) for i in range(50)]\n",
    "    data2 = [np.array([1,X2[i],Y2[i],-1]) for i in range(50)]\n",
    "    data = data1 + data2\n",
    "    \n",
    "    return data\n",
    " \n",
    "    \n",
    "\n",
    "X = []\n",
    "\n",
    "Y = []\n",
    "\n",
    "for i in range(100):\n",
    "    Y.append(data[i][3])\n",
    "#print(Y)\n",
    "\n",
    "for i in range(100):\n",
    "    X.append(data[i][:3])\n",
    "    \n",
    "    \n",
    "#The perceptron algorithm to find the weight and calculate exact target function\n",
    "def Perceptron(X, Y):\n",
    "\n",
    "    weights = [0,0,0]\n",
    "    n = 0.01\n",
    "    epoch = 10\n",
    "    iteration = 0\n",
    "\n",
    "    for k in range(epoch):\n",
    "        for i, n in enumerate(X):\n",
    "            predicted_y = np.sign(np.dot(np.transpose(weights), X[i]))    # y' = w^T *X  \n",
    "            actual_y = Y[i]\n",
    "            if (predicted_y * actual_y) >1:\n",
    "                weights = weights\n",
    "            else:\n",
    "                iteration = iteration + 1\n",
    "                weights = weights + n*(actual_y-predicted_y)*X[i]\n",
    "                   \n",
    "    print(\"No.of iterations= \" + str(iteration) )\n",
    "    return weights\n",
    "\n",
    "\n",
    "z = Perceptron(X,Y)\n",
    "print(z)\n",
    "\n",
    "w0 = z[0]\n",
    "w1 = z[1]\n",
    "w2 = z[2]\n",
    "\n",
    "slope = -w1/w2\n",
    "intercept = -w0/w2\n",
    "\n",
    "generate_points(N=100)\n",
    "\n",
    "plt.figure(figsize=(8,6), dpi=60)\n",
    "\n",
    "def abline(slope, intercept):\n",
    "     # Plot a line from slope and intercept\n",
    "     ax = plt.gca()\n",
    "     x_value = np.array(ax.get_xlim())\n",
    "     y_value = intercept + slope * x_value\n",
    "     plt.plot(x_value, y_value, '--')\n",
    "\n",
    "abline(slope,intercept)  \n",
    "\n",
    "def plot_points(data):\n",
    "\n",
    "    for i in range(100):\n",
    "        if (data[i][3] == 1):\n",
    "            plt.plot(data[i][1], data[i][2], 'ro')\n",
    "        elif (data[i][3] ==-1):\n",
    "            plt.plot (data[i][1], data[i][2], 'bo')\n",
    "        \n",
    "    plt.xlabel('X')\n",
    "    plt.ylabel('Y') \n",
    "        \n",
    "    plt.plot([-1,1], [1,-1], 'r-')\n",
    "    \n",
    "    \n",
    "plot_points(data)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No.of iterations 100000\n",
      "There are 1194 misclassfied points\n",
      "Errored value 11.940000000000001%\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.rcParams['axes.unicode_minus'] = False \n",
    "\n",
    "#generate a data set of 10000. \n",
    "#for simplicity, 5000 in the first quadrant, another 5000 in the third quadrant \n",
    "\n",
    "X1 = []\n",
    "Y1 = []\n",
    "X2 = []\n",
    "Y2 = []\n",
    "\n",
    "for i in range(5000):\n",
    "    X1.append(random.uniform(0,1))\n",
    "    Y1.append(random.uniform(0,1))\n",
    "    X2.append(random.uniform(-1,0))\n",
    "    Y2.append(random.uniform(-1,0))\n",
    "\n",
    "#label the data\n",
    "data1 = [np.array([1,X1[i],Y1[i],1]) for i in range(5000)]\n",
    "data2 = [np.array([1,X2[i],Y2[i],-1]) for i in range(5000)]\n",
    "data = data1 + data2\n",
    "\n",
    "#plt.figure(figsize=(8,8), dpi=100)\n",
    "\n",
    "X = []\n",
    "\n",
    "Y = []\n",
    "\n",
    "for i in range(10000):\n",
    "    Y.append(data[i][3])\n",
    "#print(Y)\n",
    "\n",
    "for i in range(10000):\n",
    "    X.append(data[i][:3])\n",
    "\n",
    "    \n",
    "N = 10000\n",
    "\n",
    "#The perceptron algorithm to find the weight and calculate exact target function\n",
    "def Predict(X, Y):\n",
    "    \n",
    "    misclass = 0\n",
    "    classified = 0\n",
    "    new_weights = Perceptron(X,Y)              # getting the hypothesis from training data set \n",
    "       \n",
    "    for i, n in enumerate(X):\n",
    "        predicted_y = np.sign(np.dot(np.transpose(new_weights), X[i]))    # y' = w^T *X  \n",
    "        actual_y = Y[i]\n",
    "        if predicted_y != actual_y:\n",
    "      \n",
    "             misclass += 1\n",
    "                \n",
    "    print(\"There are \" + str(misclass) + \" misclassfied points\")\n",
    "    return (misclass)\n",
    "\n",
    "\n",
    "misclassified = Predict(X,Y)\n",
    "\n",
    "def error_calc(misclassified, N):\n",
    "    errored_value = (misclassified/N)*100\n",
    "    print(\"Errored value \"+ str(errored_value)+\"%\")\n",
    "\n",
    "error_calc(misclassified, N)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.5(d) Use the data set in (a) and redo everything with n = 0. 0001. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No.of iterations= 1000\n",
      "[1.         0.15023378 0.03569212]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 480x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.rcParams['axes.unicode_minus'] = False \n",
    "\n",
    "#generate a data set of 100. \n",
    "#for simplicity, 50 in the first quadrant, another 50 in the third quadrant \n",
    "\n",
    "def generate_points(N):\n",
    "    X1 = []\n",
    "    Y1 = []\n",
    "    X2 = []\n",
    "    Y2 = []\n",
    "\n",
    "    for i in range(N):\n",
    "        X1.append(random.uniform(0,1))\n",
    "        Y1.append(random.uniform(0,1))\n",
    "        X2.append(random.uniform(-1,0))\n",
    "        Y2.append(random.uniform(-1,0))\n",
    "        \n",
    "    #label the data\n",
    "    data1 = [np.array([1,X1[i],Y1[i],1]) for i in range(50)]\n",
    "    data2 = [np.array([1,X2[i],Y2[i],-1]) for i in range(50)]\n",
    "    data = data1 + data2\n",
    "    \n",
    "    return data\n",
    " \n",
    "    \n",
    "\n",
    "X = []\n",
    "\n",
    "Y = []\n",
    "\n",
    "for i in range(100):\n",
    "    Y.append(data[i][3])\n",
    "#print(Y)\n",
    "\n",
    "for i in range(100):\n",
    "    X.append(data[i][:3])\n",
    "    \n",
    "    \n",
    "#The perceptron algorithm to find the weight and calculate exact target function\n",
    "def Perceptron(X, Y):\n",
    "\n",
    "    weights = [0,0,0]\n",
    "    n = 0.001\n",
    "    epoch = 10\n",
    "    iteration = 0\n",
    "\n",
    "    for k in range(epoch):\n",
    "        for i, n in enumerate(X):\n",
    "            predicted_y = np.sign(np.dot(np.transpose(weights), X[i]))    # y' = w^T *X  \n",
    "            actual_y = Y[i]\n",
    "            if (predicted_y * actual_y) >1:\n",
    "                weights = weights\n",
    "            else:\n",
    "                iteration = iteration + 1\n",
    "                weights = weights + n*(actual_y-predicted_y)*X[i]\n",
    "                   \n",
    "    print(\"No.of iterations= \" + str(iteration) )\n",
    "    return weights\n",
    "\n",
    "\n",
    "z = Perceptron(X,Y)\n",
    "print(z)\n",
    "\n",
    "w0 = z[0]\n",
    "w1 = z[1]\n",
    "w2 = z[2]\n",
    "\n",
    "slope = -w1/w2\n",
    "intercept = -w0/w2\n",
    "\n",
    "generate_points(N=100)\n",
    "\n",
    "plt.figure(figsize=(8,6), dpi=60)\n",
    "\n",
    "def abline(slope, intercept):\n",
    "     # Plot a line from slope and intercept\n",
    "     ax = plt.gca()\n",
    "     x_value = np.array(ax.get_xlim())\n",
    "     y_value = intercept + slope * x_value\n",
    "     plt.plot(x_value, y_value, '--')\n",
    "\n",
    "abline(slope,intercept)  \n",
    "\n",
    "def plot_points(data):\n",
    "\n",
    "    for i in range(100):\n",
    "        if (data[i][3] == 1):\n",
    "            plt.plot(data[i][1], data[i][2], 'ro')\n",
    "        elif (data[i][3] ==-1):\n",
    "            plt.plot (data[i][1], data[i][2], 'bo')\n",
    "        \n",
    "    plt.xlabel('X')\n",
    "    plt.ylabel('Y') \n",
    "        \n",
    "    plt.plot([-1,1], [1,-1], 'r-')\n",
    "    \n",
    "    \n",
    "plot_points(data)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No.of iterations= 100000\n",
      "There are 6516 misclassfied points\n",
      "Errored value 65.16%\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.rcParams['axes.unicode_minus'] = False \n",
    "\n",
    "#generate a data set of 10000. \n",
    "#for simplicity, 5000 in the first quadrant, another 5000 in the third quadrant \n",
    "\n",
    "X1 = []\n",
    "Y1 = []\n",
    "X2 = []\n",
    "Y2 = []\n",
    "\n",
    "for i in range(5000):\n",
    "    X1.append(random.uniform(0,1))\n",
    "    Y1.append(random.uniform(0,1))\n",
    "    X2.append(random.uniform(-1,0))\n",
    "    Y2.append(random.uniform(-1,0))\n",
    "\n",
    "#label the data\n",
    "data1 = [np.array([1,X1[i],Y1[i],1]) for i in range(5000)]\n",
    "data2 = [np.array([1,X2[i],Y2[i],-1]) for i in range(5000)]\n",
    "data = data1 + data2\n",
    "\n",
    "#plt.figure(figsize=(8,8), dpi=100)\n",
    "\n",
    "X = []\n",
    "\n",
    "Y = []\n",
    "\n",
    "for i in range(10000):\n",
    "    Y.append(data[i][3])\n",
    "#print(Y)\n",
    "\n",
    "for i in range(10000):\n",
    "    X.append(data[i][:3])\n",
    "\n",
    "    \n",
    "N = 10000\n",
    "\n",
    "#The perceptron algorithm to find the weight and calculate exact target function\n",
    "def Predict(X, Y):\n",
    "    \n",
    "    misclass = 0\n",
    "    classified = 0\n",
    "    new_weights = Perceptron(X,Y)              # getting the hypothesis from training data set \n",
    "       \n",
    "    for i, n in enumerate(X):\n",
    "        predicted_y = np.sign(np.dot(np.transpose(new_weights), X[i]))    # y' = w^T *X  \n",
    "        actual_y = Y[i]\n",
    "        if predicted_y != actual_y:\n",
    "      \n",
    "             misclass += 1\n",
    "                \n",
    "    print(\"There are \" + str(misclass) + \" misclassfied points\")\n",
    "    return (misclass)\n",
    "\n",
    "\n",
    "misclassified = Predict(X,Y)\n",
    "\n",
    "def error_calc(misclassified, N):\n",
    "    errored_value = (misclassified/N)*100\n",
    "    print(\"Errored value \"+ str(errored_value)+\"%\")\n",
    "\n",
    "error_calc(misclassified, N)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.5 (e) Compare the results that you get from (a) to (d ) ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### we may notice that when n = 0.001, the % of misclassified points is less when compared to other vlues of n."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Note : Due to randomness of the data set,  error % keeps changing while running the program everytime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}