Logistic Regression (Multi-class).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "smai a2 q2.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-g0bD6IALZdq"
      },
      "source": [
        "You need to implement Logistic Regression from scratch in this question\n",
        "\n",
        "1. You are provided with the dataset of sign language digits. Implement logistic regression from scratch to classify the images provided in the dataset. Load the dataset and perform splitting into training and test sets with 70:30 ratio randomly using test train split.\n",
        "    \n",
        "dataset link : https://iiitaphyd-my.sharepoint.com/:f:/g/personal/apurva_jadhav_students_iiit_ac_in/Eictt5_qmoxNqezgQQiMWeIBph4sxlfA6jWAJNPnV2SF9Q?e=mQmYN0\n",
        "\n",
        "3. Use both one vs all and one vs one method for the above problem statement purpose."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l-IFpeC7hyqK"
      },
      "source": [
        "import numpy as np\n",
        "from sklearn.model_selection import train_test_split # to split data into training sets and test sets\n",
        "import pandas as pd\n",
        "import pandas as pd\n",
        "import statistics\n",
        "from random import seed\n",
        "from sklearn.model_selection import train_test_split # to split data into training sets and test sets\n",
        "from scipy import stats\n",
        "from itertools import combinations"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HCNg_Qm9slYk",
        "outputId": "4afe4026-15f6-4ded-caae-53fb3ba6715e"
      },
      "source": [
        "!apt install unzip\n",
        "!unzip SMAI_Log_reg_dataset.zip\n",
        "!unzip SMAI_Log_reg_dataset/X.npy.zip"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "unzip is already the newest version (6.0-21ubuntu1.1).\n",
            "0 upgraded, 0 newly installed, 0 to remove and 29 not upgraded.\n",
            "Archive:  SMAI_Log_reg_dataset.zip\n",
            " extracting: SMAI_Log_reg_dataset/titanic.csv  \n",
            " extracting: SMAI_Log_reg_dataset/X.npy.zip  \n",
            " extracting: SMAI_Log_reg_dataset/Y.npy  \n",
            "Archive:  SMAI_Log_reg_dataset/X.npy.zip\n",
            "  inflating: X.npy                   \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fmbF6Ofxh0SP"
      },
      "source": [
        "PRE-PROCESSING OF DATA"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9HYZk-sXJZg8"
      },
      "source": [
        "x_l = np.load(\"X.npy\") # image\n",
        "y_l = np.load(\"SMAI_Log_reg_dataset/Y.npy\") # label\n",
        "\n",
        "x_train, x_test, y_train, y_test = train_test_split(x_l, y_l, test_size=0.3, random_state=32)\n",
        "\n",
        "#print(x_train[:10])\n",
        "# print(y_train[:10])\n",
        "# print(x_test[:10])\n",
        "# print(y_test[:10])\n",
        "\n",
        "x_l=np.reshape(x_l,(x_l.shape[0], -1))\n",
        "\n",
        "\n",
        "# print(x_train.shape)\n",
        "# print(y_train.shape)\n",
        "# print(x_test.shape)\n",
        "# print(y_test.shape)\n",
        "\n",
        "#print(x_l.shape)"
      ],
      "execution_count": 39,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rL3IAZ5bv18p"
      },
      "source": [
        "#hypothesis that takes the input variables and theta. It returns the calculated output variable.\n",
        "def hypothesis(theta, X):\n",
        "  return 1 / (1 + np.exp(-(np.dot(X,theta)))) - 0.0000001\n",
        "\n",
        "def gradient_descent(x, y, theta, alpha, epoch):\n",
        "    for i in range(epoch):\n",
        "        for j in range(0, 10):\n",
        "            theta1=theta[:,j].reshape(-1,1)\n",
        "            h = hypothesis(theta1, x)\n",
        "            for k in range(0, theta.shape[0]):\n",
        "                temp_y= y[:,j].reshape(-1,1)\n",
        "                temp_x=x[:, k].reshape(-1,1)\n",
        "                theta[k][j] -= (alpha/len(x)) * np.sum((h-temp_y)*temp_x)\n",
        "    return theta\n",
        "\n",
        "\n",
        "temp=[]\n",
        "for i in range(0,10):\n",
        "  temp.append(i)\n",
        "combo=list(combinations(temp,2)) "
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l1U92YgO3EDC"
      },
      "source": [
        "#print(x_test.shape)\n",
        "#print(x_train.shape)\n",
        "\n",
        "x_train=np.reshape(x_train,(x_train.shape[0], -1))\n",
        "ones=np.ones(shape=x_train.shape[0]).reshape(-1,1)\n",
        "x_train=np.concatenate((ones,x_train),1)\n",
        "\n",
        "x_test=np.reshape(x_test,(x_test.shape[0], -1))\n",
        "ones=np.ones(shape=x_test.shape[0]).reshape(-1,1)\n",
        "x_test=np.concatenate((ones,x_test),1)\n",
        "\n",
        "\n",
        "#print(x_test.shape)\n",
        "#print(x_train.shape)\n"
      ],
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h94GJEoUjbC-"
      },
      "source": [
        "ONE VS ALL METHOD : "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ub8v_ztMqpv9",
        "outputId": "86da47ea-3055-4ca5-be13-099c7bb85c91"
      },
      "source": [
        "\n",
        "\n",
        "theta = np.zeros([x_train.shape[1], y_train.shape[1]])\n",
        "#print(len(theta),len(theta[0]))\n",
        "theta = gradient_descent(x_train, y_train, theta, 0.01, 1000)\n",
        "\n",
        "\n",
        "# With this updated theta, calculate the output variable.\n",
        "#print(len(theta),len(theta[0]))\n",
        "#print(x_test.shape)\n",
        "#print(\"***************\")\n",
        "output = []\n",
        "for i in range(0, 10):\n",
        "    #theta1 = pd.DataFrame(theta)\n",
        "    #h = hypothesis(theta1.iloc[:,i], x_test)\n",
        "    theta1=theta[:,i].reshape(-1,1)\n",
        "    h = hypothesis(theta1, x_test)\n",
        "\n",
        "    output.append(h)\n",
        "\n",
        "\n",
        "output=np.array(output)\n",
        "\n",
        "accuracy = 0\n",
        "for col in range(0, 10):\n",
        "    for row in range(len(y_test)):\n",
        "        temp=output[:,row].reshape(-1,1)\n",
        "        if y_test[row][col] == 1 and output[col][row] == max(temp):\n",
        "            accuracy += 1\n",
        "\n",
        "accuracy = accuracy/len(x_test)\n",
        "print(accuracy*100)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "70.75928917609046\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vsp5lvV0zZVk"
      },
      "source": [
        "output1=[]\n",
        "for i in range(len(output)):\n",
        "  ll=[]\n",
        "  for j in range(len(output[0])):\n",
        "    ll.append(output[i][j][0])\n",
        "  output1.append(ll)\n",
        "\n",
        "output1=np.array(output1).transpose()\n",
        "onevsall_y=[]\n",
        "for i in output1:\n",
        "  onevsall_y.append(np.argmax(i))\n",
        "onevsall_y=np.array(onevsall_y)\n",
        "#print(onevsall_y.shape)"
      ],
      "execution_count": 69,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sfN_GsbajxLX"
      },
      "source": [
        "ONE VS ONE :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bDAJiD6O3Nym",
        "outputId": "0ba438ee-ef41-4359-8630-dfaf516090b7"
      },
      "source": [
        "theta=[]\n",
        "for pair in combo:\n",
        "    a=pair[0]\n",
        "    b=pair[1]\n",
        "    \n",
        "    temp_x=[]\n",
        "    temp_y=[]\n",
        "\n",
        "    for i in range(len(y_train)):\n",
        "      if np.argmax(y_train[i])==a or np.argmax(y_train[i])==b :\n",
        "        temp_x.append(x_train[i])\n",
        "        temp_y.append(y_train[i][a])\n",
        "\n",
        "    w=np.zeros(4097)\n",
        "    diff=[]\n",
        "    epoch=1000\n",
        "    alpha=0.1\n",
        "    for i in range(epoch):\n",
        "      y_predict=1 / (1 + np.exp(-(np.dot(temp_x,w)))) - 0.0000001\n",
        "      cost=np.subtract(y_predict,temp_y)\n",
        "      diff.append(cost)\n",
        "      t=[]\n",
        "      t=np.dot(np.array(temp_x).T,cost)\n",
        "      t1=t*(alpha/len(temp_y))\n",
        "      w=w-t1\n",
        "    \n",
        "    theta.append(w)\n",
        "\n",
        "y_pred=[]\n",
        "\n",
        "for i in x_test :\n",
        "  l=[]\n",
        "  for j in range(len(theta)):\n",
        "    hypo=hypothesis(i, theta[j])\n",
        "    if hypo>=0.5:\n",
        "      l.append(combo[j][0])\n",
        "    else:\n",
        "      l.append(combo[j][1])\n",
        "\n",
        "  aa=stats.mode(l)\n",
        "  y_pred.append(aa)\n",
        "\n",
        "#print(y_pred)\n",
        "\n",
        "accuracy=0\n",
        "for i in range(len(y_test)):\n",
        "  if np.argmax(y_test[i])==y_pred[i][0][0]:\n",
        "    accuracy+=1\n",
        "\n",
        "accuracy = accuracy/len(x_test)\n",
        "print(accuracy*100)\n"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "72.21324717285945\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sLi-hZ_jzCXa"
      },
      "source": [
        "y_pred_one_one=[]\n",
        "for i in y_pred:\n",
        "  y_pred_one_one.append(i[0])\n"
      ],
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JKS1KZiSAL8-"
      },
      "source": [
        "2.\n",
        "a) Plot a diagram for the sigmoid function. This is used for binary classication.\n",
        "b) How do you modify it for multilabel dataset classification problems? State and Explain the methods used.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "qm5O0NLQqZDV",
        "outputId": "2690b082-821c-4ff6-e9a6-2b342f341aa7"
      },
      "source": [
        "import matplotlib.pyplot as plt \n",
        "import numpy as np \n",
        "import math \n",
        "  \n",
        "x = np.linspace(-10, 10, 100) \n",
        "z = 1/(1 + np.exp(-x)) \n",
        "  \n",
        "plt.plot(x, z) \n",
        "plt.xlabel(\"x\") \n",
        "plt.ylabel(\"Sigmoid(X)\") \n",
        "  \n",
        "plt.show() "
      ],
      "execution_count": 10,
      "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": {
        "id": "fM3d7HoZrUyM"
      },
      "source": [
        "Ans. 2b) If the inputs of your classification task have multiple labels for an input, your classes are not mutually exclusive and you can use Sigmoid for each output. Logistic regression uses a sigmoid function to predict the output. The sigmoid function returns a value from 0 to 1. Generally, we take a threshold such as 0.5. If the sigmoid function returns a value greater than or equal to 0.5, we take it as 1, and if the sigmoid function returns a value less than 0.5, we take it as 0.\n",
        "\n",
        "h= 1 / (1 + e^(-z)) - 0.0000001\n",
        "\n",
        "where z =  input features multiplied by theta(t)\n",
        "\n",
        "X = [X1, X2, X3] are input features\n",
        "\n",
        "Hence, h= t0 + t1*X1 + t2*X2 + ...."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-ikPh-dzw1jM"
      },
      "source": [
        "(q3 done along with q1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "on8-jl9-nJfF"
      },
      "source": [
        "4. Also get results using Log Reg from scikit learn.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wUny0qv5sgGm",
        "outputId": "c47a2d43-9a3e-48b4-af11-ec3288b8da44"
      },
      "source": [
        "from sklearn import datasets\n",
        "from sklearn import model_selection\n",
        "from sklearn import linear_model\n",
        "from sklearn import metrics\n",
        "\n",
        "\n",
        "y_train1=[]\n",
        "for yy in y_train:\n",
        "  y_train1.append(np.argmax(yy))\n",
        "y_train1=np.array(y_train1)\n",
        "\n",
        "y_test1=[]\n",
        "for yy in y_test:\n",
        "  y_test1.append(np.argmax(yy))\n",
        "y_test1=np.array(y_test1)\n",
        "\n",
        "# print(x_train.shape)\n",
        "# print(y_train1.shape)\n",
        "# print(x_test.shape)\n",
        "# print(y_test1.shape)\n",
        "\n",
        "lm = linear_model.LogisticRegression(multi_class='ovr', solver='liblinear')\n",
        "lm.fit(x_train, y_train1)\n",
        "y_sklearn=lm.predict(x_test)\n",
        "print(\"SCORE FROM Log Reg from scikit learn\")\n",
        "lm.score(x_test, y_test1)\n"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "SCORE FROM Log Reg from scikit learn\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7140549273021002"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KEjGyjPcvDBU"
      },
      "source": [
        "5. Report metrics you feel useful and Compare the results - from all the three.\n",
        "\n",
        "A] ACCURACY SCORE :\n",
        "<br>\n",
        "one vs all : 0.7075928917609046\n",
        "<br>\n",
        "one vs one : 0.7221324717285945\n",
        "<br>\n",
        "scikit learn : 0.7172859450726979\n",
        "<br><br>\n",
        "\n",
        "From the above score, we can see that one vs one gave the maximum accuracy out of all 3 methods.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Ck5f6c_7Z6M"
      },
      "source": [
        "B] CONFUSION MATRIX :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TOpCzY703UOW",
        "outputId": "ff4b645b-4cfa-4867-a0f9-3dec6ab06781"
      },
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "print(\"y_test vs onevsall : \")\n",
        "confusion_matrix(y_test1, onevsall_y)"
      ],
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "y_test vs onevsall : \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[50,  2,  2,  0,  0,  0,  2,  0,  1,  3],\n",
              "       [ 1, 47,  1,  5,  0,  1,  3,  0,  0,  0],\n",
              "       [ 0,  4, 30,  3,  3,  0,  2,  0,  5,  0],\n",
              "       [ 0,  0,  2, 52,  1,  0,  4,  0,  4,  0],\n",
              "       [ 0,  1,  2,  0, 41,  5,  1,  1,  1,  0],\n",
              "       [ 4,  2,  3,  1,  2, 51,  1,  0,  1,  1],\n",
              "       [ 1,  1,  8, 12,  0,  5, 26,  0,  5,  2],\n",
              "       [ 5,  0,  2,  0,  4,  0,  0, 49,  3,  8],\n",
              "       [ 1,  2, 14,  3, 10,  0,  0,  0, 42,  0],\n",
              "       [ 9,  0,  1,  0,  0,  2,  3,  5,  0, 50]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qoOORE6X7LOT",
        "outputId": "2cbbacd1-152e-40e5-ba29-8c3410f7d003"
      },
      "source": [
        "print(\"y_test vs onevsone : \")\n",
        "confusion_matrix(y_test1, y_pred_one_one)\n"
      ],
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "y_test vs onevsone : \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[52,  1,  2,  0,  0,  0,  1,  0,  1,  3],\n",
              "       [ 2, 49,  0,  5,  0,  0,  2,  0,  0,  0],\n",
              "       [ 0,  4, 22,  3,  7,  2,  1,  1,  7,  0],\n",
              "       [ 0,  0,  0, 45,  1,  3,  0,  1, 13,  0],\n",
              "       [ 0,  2,  0,  0, 45,  3,  0,  1,  1,  0],\n",
              "       [ 2,  1,  0,  1,  2, 57,  0,  0,  1,  2],\n",
              "       [ 4,  3,  3, 24,  0, 11,  9,  0,  5,  1],\n",
              "       [ 3,  0,  1,  2,  0,  0,  0, 57,  1,  7],\n",
              "       [ 1,  1,  3,  3,  8,  1,  0,  2, 52,  1],\n",
              "       [ 4,  0,  0,  0,  0,  3,  2,  2,  0, 59]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m03hX-5f7LD3",
        "outputId": "79ec5191-0b40-45e8-b692-63ddbe48435c"
      },
      "source": [
        "print(\"onevsall vs sklearn : \")\n",
        "confusion_matrix(onevsall_y,y_sklearn)\n"
      ],
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "onevsall vs sklearn : \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[56,  1,  0,  2,  1,  1,  0,  4,  0,  6],\n",
              "       [ 2, 50,  1,  0,  0,  2,  3,  0,  1,  0],\n",
              "       [ 0,  0, 40,  7,  5,  2,  7,  1,  2,  1],\n",
              "       [ 0,  2,  0, 46,  0,  2, 12,  0, 14,  0],\n",
              "       [ 0,  0,  3,  4, 47,  2,  0,  3,  2,  0],\n",
              "       [ 1,  3,  0,  1,  2, 53,  0,  0,  1,  3],\n",
              "       [ 0,  2,  3,  2,  0,  2, 32,  0,  0,  1],\n",
              "       [ 1,  0,  0,  2,  1,  0,  1, 43,  0,  7],\n",
              "       [ 0,  1,  1,  5,  4,  0,  4,  2, 45,  0],\n",
              "       [ 0,  2,  0,  2,  0,  1,  2,  5,  0, 52]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MldUmOUr7N3E",
        "outputId": "f294f73c-0d38-4e59-ec7f-e7b66f988cdd"
      },
      "source": [
        "print(\"onevsone vs sklearn : \")\n",
        "confusion_matrix(y_pred_one_one,y_sklearn)\n"
      ],
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "onevsone vs sklearn : \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[53,  3,  1,  3,  1,  1,  2,  3,  0,  1],\n",
              "       [ 1, 50,  3,  1,  0,  2,  4,  0,  0,  0],\n",
              "       [ 0,  0, 27,  0,  2,  1,  1,  0,  0,  0],\n",
              "       [ 0,  2,  2, 47,  1,  1, 23,  0,  7,  0],\n",
              "       [ 0,  0,  6,  5, 47,  2,  3,  0,  0,  0],\n",
              "       [ 2,  2,  2,  1,  3, 55, 12,  0,  1,  2],\n",
              "       [ 0,  2,  2,  0,  0,  0, 10,  0,  0,  1],\n",
              "       [ 2,  0,  1,  3,  2,  1,  0, 51,  2,  2],\n",
              "       [ 0,  1,  4, 11,  4,  0,  4,  2, 55,  0],\n",
              "       [ 2,  1,  0,  0,  0,  2,  2,  2,  0, 64]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 68
        }
      ]
    }
  ]
}