From 3b8459eadd7fa3ea15ec5c67385b49a0b0fbb74f Mon Sep 17 00:00:00 2001 From: Vivek Patidar <77988917+vivekpatidar1413@users.noreply.github.com> Date: Thu, 25 Mar 2021 04:36:23 +0530 Subject: [PATCH 1/4] Created using Colaboratory --- MNIST_LogisticRegression_FINAL.ipynb | 823 +++++++++++++++++++++++++++ 1 file changed, 823 insertions(+) create mode 100644 MNIST_LogisticRegression_FINAL.ipynb diff --git a/MNIST_LogisticRegression_FINAL.ipynb b/MNIST_LogisticRegression_FINAL.ipynb new file mode 100644 index 0000000..dde820d --- /dev/null +++ b/MNIST_LogisticRegression_FINAL.ipynb @@ -0,0 +1,823 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "MNIST_LogisticRegression_FINAL.ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true, + "authorship_tag": "ABX9TyOnPHyJdtjB1OAviYcOeHqC", + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "osM8JPRAlth8" + }, + "source": [ + "# Importing The MNIST dataset\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "qaP_jRa_lFb6" + }, + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt" + ], + "execution_count": 252, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "RTvWtumslXXF" + }, + "source": [ + "train_df = pd.read_csv(\"/content/sample_data/mnist_train_small.csv\")\n", + "test_df = pd.read_csv(\"/content/sample_data/mnist_test.csv\")" + ], + "execution_count": 299, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GX-d4zh3JFJL" + }, + "source": [ + "converting the data frame into numpy array" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "leL1lkgrlbMg" + }, + "source": [ + "train = train_df.to_numpy()\n", + "test = test_df.to_numpy()" + ], + "execution_count": 300, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZVCA5mGRlfxH", + "outputId": "3d57557c-c975-4534-c324-5b0b2f261cb2" + }, + "source": [ + "print(train.shape)\n", + "print(train)" + ], + "execution_count": 301, + "outputs": [ + { + "output_type": "stream", + "text": [ + "(19999, 785)\n", + "[[5 0 0 ... 0 0 0]\n", + " [7 0 0 ... 0 0 0]\n", + " [9 0 0 ... 0 0 0]\n", + " ...\n", + " [2 0 0 ... 0 0 0]\n", + " [9 0 0 ... 0 0 0]\n", + " [5 0 0 ... 0 0 0]]\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zH4eRqDhrg_7" + }, + "source": [ + "# Reshaping the dataset into desired shape and Size" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "VYypfC6jmPjU" + }, + "source": [ + "x_train = train[:,1:]\n", + "y_train = train[:,:1]" + ], + "execution_count": 302, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Qfr-vX0A9gQh", + "outputId": "e239e66a-c240-493c-f336-9391a3bc2790" + }, + "source": [ + "y_train" + ], + "execution_count": 303, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[5],\n", + " [7],\n", + " [9],\n", + " ...,\n", + " [2],\n", + " [9],\n", + " [5]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 303 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "m3R9C7NzKQrN" + }, + "source": [ + "# Adding one more coloumn to x_train so we can take dot product of it with THEETA\n", + "\n", + "x_n_train = np.arange(19999*785)\n", + "x_n_train = np.reshape(x_n_train,(19999,785))\n", + "\n", + "for i in range(19999):\n", + " x_n_train[i] = np.insert(x_train[i],0,1)\n", + "x_n_train = x_n_train/255" + ], + "execution_count": 258, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rGjSX1j6mYxK", + "outputId": "17955923-f4c8-4a22-d76d-545d1e2777e5" + }, + "source": [ + "print(y_train.shape)\n", + "print(x_n_train.shape)" + ], + "execution_count": 259, + "outputs": [ + { + "output_type": "stream", + "text": [ + "(19999, 1)\n", + "(19999, 785)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QO2-tBp5KaP_" + }, + "source": [ + "# THE MAIN FUNCTION" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F5FudWz46l-Q" + }, + "source": [ + "Defining a function which we call for diffrent digit classification\n", + "\n", + "* input = taking the digit for which the classification is to be performed\n", + "* output = the values of theeta and cost function after every iteration\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yCcBbllQm1Zb" + }, + "source": [ + "def THE_MAIN_FUNCTION(n,X,Y):\n", + "\n", + " # Let the iterations be 50000\n", + " itrations = 50000\n", + " # let the learning rate be 0.16\n", + " alpha = 0.16\n", + " # the number of training set be m which is 19999 here\n", + " m = 19999\n", + "\n", + " '''Converting the Y_TRAIN in BINARY FORM'''\n", + " '''Y be 1 if the number is same as the digit to be trained(n)'''\n", + " '''Y be 0 if the number is not equal as the digit to be trained(n)'''\n", + " for i in range(19999):\n", + " if Y[i]==n:\n", + " Y[i]=1\n", + " else:\n", + " Y[i]=0\n", + "\n", + " Y = Y.T\n", + " X = X.T\n", + " \n", + " # Intialising the array of theeta to be any random value \n", + " Theeta = np.random.randn(1,785)\n", + "\n", + " Cost_Function = []\n", + " k = 0\n", + "\n", + " print('TRAINING THE MODEL FOR DIGIT',n)\n", + "\n", + "\n", + " # The main itration loops bigins from here\n", + "\n", + " for i in range(1,itrations+1):\n", + " \n", + " g = np.dot(Theeta,X)\n", + " hypothesis = 1/(1 + np.exp(-g))\n", + "\n", + " # COST FUNCTION\n", + " j = 1/m*(-1*(np.sum(y*np.log(hypothesis) + (1-y)*np.log(1-hypothesis))))\n", + " Cost_Function.append(j)\n", + " \n", + " # GRADIENT DESCENT\n", + " dw = 1/m * np.dot(hypothesis-y,X.T)\n", + " Theeta = Theeta - alpha*dw\n", + " \n", + " k+=1\n", + "\n", + " if i%2500 == 0:\n", + " print(i,'th Iteration , Cost Function =',j)\n", + "\n", + "\n", + " # BREAKING THE LOOP\n", + " '''stoping the loop if the change in value of cost function is too low'''\n", + " if i%2 == 0:\n", + " if abs(j-Cost_Function[-2])<0.000001:\n", + " if abs(j-Cost_Function[-3])<0.000001:\n", + " break \n", + "\n", + " \n", + " print('Last itteration number:',k)\n", + "\n", + " return Theeta,Cost_Function" + ], + "execution_count": 260, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JeuONSUW9bs5", + "outputId": "b41f7c1a-315c-45c9-e142-6673fab48b85" + }, + "source": [ + "y_train" + ], + "execution_count": 261, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[5],\n", + " [7],\n", + " [9],\n", + " ...,\n", + " [2],\n", + " [9],\n", + " [5]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 261 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "D4aRqZiv7XdB", + "outputId": "897477e9-7bee-41c8-8659-178ac6f4916f" + }, + "source": [ + "Theeta0 , Cost_Function0 = THE_MAIN_FUNCTION (0,x_n_train,y_train)\n", + "Theeta1 , Cost_Function1 = THE_MAIN_FUNCTION (1,x_n_train,y_train)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PCFnxnxk7XLX", + "outputId": "5506526d-af04-4bcc-9a46-0ba5330a907d" + }, + "source": [ + "Theeta2 , Cost_Function2 = THE_MAIN_FUNCTION (2,x_n_train,y_train)\n", + "Theeta3 , Cost_Function3 = THE_MAIN_FUNCTION (3,x_n_train,y_train)" + ], + "execution_count": 283, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 2\n", + "2500 th Iteration , Cost Function = 0.1607660698588981\n", + "5000 th Iteration , Cost Function = 0.1393396118952187\n", + "7500 th Iteration , Cost Function = 0.12871299110338633\n", + "10000 th Iteration , Cost Function = 0.12244428053826896\n", + "12500 th Iteration , Cost Function = 0.11833725787237213\n", + "15000 th Iteration , Cost Function = 0.11542773917973478\n", + "17500 th Iteration , Cost Function = 0.11324671674754491\n", + "20000 th Iteration , Cost Function = 0.11154340654638314\n", + "Last itteration number: 22384\n", + "TRAINING THE MODEL FOR DIGIT 3\n", + "2500 th Iteration , Cost Function = 0.15306421187442873\n", + "5000 th Iteration , Cost Function = 0.13550435155682145\n", + "7500 th Iteration , Cost Function = 0.12677966547437963\n", + "10000 th Iteration , Cost Function = 0.1212933004236208\n", + "12500 th Iteration , Cost Function = 0.11748858517797098\n", + "15000 th Iteration , Cost Function = 0.11469517403265396\n", + "17500 th Iteration , Cost Function = 0.11256109843915171\n", + "20000 th Iteration , Cost Function = 0.11088041310116029\n", + "Last itteration number: 22242\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_XLJ8odN7XC3", + "outputId": "c68ce35c-c85f-4902-ed7e-880c43c2739d" + }, + "source": [ + "Theeta4 , Cost_Function4 = THE_MAIN_FUNCTION (4,x_n_train,y_train)\n", + "Theeta5 , Cost_Function5 = THE_MAIN_FUNCTION (5,x_n_train,y_train)" + ], + "execution_count": 290, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 4\n", + "2500 th Iteration , Cost Function = 0.16298380705984145\n", + "5000 th Iteration , Cost Function = 0.139839825842285\n", + "7500 th Iteration , Cost Function = 0.12866520104211718\n", + "10000 th Iteration , Cost Function = 0.12202435409355492\n", + "12500 th Iteration , Cost Function = 0.11768963294988785\n", + "15000 th Iteration , Cost Function = 0.11466676002957774\n", + "17500 th Iteration , Cost Function = 0.11244411766850919\n", + "20000 th Iteration , Cost Function = 0.11073848257672324\n", + "Last itteration number: 22160\n", + "TRAINING THE MODEL FOR DIGIT 5\n", + "2500 th Iteration , Cost Function = 0.15844287804808602\n", + "5000 th Iteration , Cost Function = 0.13802816076532912\n", + "7500 th Iteration , Cost Function = 0.12873632489043024\n", + "10000 th Iteration , Cost Function = 0.12298950857291657\n", + "12500 th Iteration , Cost Function = 0.11899804108579794\n", + "15000 th Iteration , Cost Function = 0.11605109991836136\n", + "17500 th Iteration , Cost Function = 0.11378308256431212\n", + "20000 th Iteration , Cost Function = 0.11198233941170184\n", + "22500 th Iteration , Cost Function = 0.11051751244755166\n", + "Last itteration number: 23328\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "UthB_T3L7W8o", + "outputId": "4a332cbb-bd93-4606-94ee-b0e3bf16852b" + }, + "source": [ + "Theeta6 , Cost_Function6 = THE_MAIN_FUNCTION (6,x_n_train,y_train)\n", + "Theeta7 , Cost_Function7 = THE_MAIN_FUNCTION (7,x_n_train,y_train)" + ], + "execution_count": 291, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 6\n", + "2500 th Iteration , Cost Function = 0.1714616185234725\n", + "5000 th Iteration , Cost Function = 0.1437025475889099\n", + "7500 th Iteration , Cost Function = 0.1308038895898387\n", + "10000 th Iteration , Cost Function = 0.12340007695639414\n", + "12500 th Iteration , Cost Function = 0.11867385536845006\n", + "15000 th Iteration , Cost Function = 0.11542695702086883\n", + "17500 th Iteration , Cost Function = 0.11306198916969501\n", + "20000 th Iteration , Cost Function = 0.11125754701459145\n", + "22500 th Iteration , Cost Function = 0.10983023644556258\n", + "Last itteration number: 22790\n", + "TRAINING THE MODEL FOR DIGIT 7\n", + "2500 th Iteration , Cost Function = 0.15952220493336014\n", + "5000 th Iteration , Cost Function = 0.13812956227564244\n", + "7500 th Iteration , Cost Function = 0.12811159893187082\n", + "10000 th Iteration , Cost Function = 0.12211694987942844\n", + "12500 th Iteration , Cost Function = 0.11810763972752984\n", + "15000 th Iteration , Cost Function = 0.11522924292505\n", + "17500 th Iteration , Cost Function = 0.11305896067961005\n", + "20000 th Iteration , Cost Function = 0.11136281392826651\n", + "Last itteration number: 22286\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KCb4VacsOM6R", + "outputId": "786c1acc-b4a5-469d-e24d-4e24e82c55ce" + }, + "source": [ + "Theeta8 , Cost_Function8 = THE_MAIN_FUNCTION (8,x_n_train,y_train)\n", + "Theeta9 , Cost_Function9 = THE_MAIN_FUNCTION (9,x_n_train,y_train)" + ], + "execution_count": 292, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 8\n", + "2500 th Iteration , Cost Function = 0.15635284907757438\n", + "5000 th Iteration , Cost Function = 0.13594577244707792\n", + "7500 th Iteration , Cost Function = 0.12602551896660513\n", + "10000 th Iteration , Cost Function = 0.1201016553845599\n", + "12500 th Iteration , Cost Function = 0.11622000971339194\n", + "15000 th Iteration , Cost Function = 0.11350382605079457\n", + "17500 th Iteration , Cost Function = 0.11150396136946798\n", + "20000 th Iteration , Cost Function = 0.1099711553661623\n", + "Last itteration number: 20880\n", + "TRAINING THE MODEL FOR DIGIT 9\n", + "2500 th Iteration , Cost Function = 0.15352926625817928\n", + "5000 th Iteration , Cost Function = 0.13402590922197494\n", + "7500 th Iteration , Cost Function = 0.12542204786260167\n", + "10000 th Iteration , Cost Function = 0.12030469795649451\n", + "12500 th Iteration , Cost Function = 0.11680222114344448\n", + "15000 th Iteration , Cost Function = 0.11422815570729013\n", + "17500 th Iteration , Cost Function = 0.11225286137768155\n", + "20000 th Iteration , Cost Function = 0.11069029467647659\n", + "Last itteration number: 21376\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZcTVHYnrHmyw" + }, + "source": [ + "# Graph Ploting for Cost Function" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JbOYoSAtLLex" + }, + "source": [ + "Graph Showing the decresing nature of cost function \n", + "\n", + "* number of iterations on x-axis\n", + "* cost function value on y-axis\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "Edo3gOe8ERVs", + "outputId": "f6342f89-090a-4154-a5e3-ec43c951e768" + }, + "source": [ + "plt.plot(Cost_Function0)\n", + "plt.title(\"0's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function1)\n", + "plt.title(\"1's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function2)\n", + "plt.title(\"2's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function3)\n", + "plt.title(\"3's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function4)\n", + "plt.title(\"4's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function5)\n", + "plt.title(\"5's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function6)\n", + "plt.title(\"6's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function7)\n", + "plt.title(\"7's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function8)\n", + "plt.title(\"8's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function9)\n", + "plt.title(\"9's dataset\")\n", + "plt.show()" + ], + "execution_count": 293, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAajUlEQVR4nO3dfZAc9X3n8fdnZh/0jEBaQAgJYYOL4CcelofEjovDhw2EQFLBF+zY4Kco5TJlfJe7FCQ5bHOpq/iuYl9RcKYUIAbHMdjgw7IDZSsHDrHPCC9YPEgKZsEQJAu0SELSImml3f3eH9276hn17MyuZh969HlVTU33r3/d/evW7Gdav57uVkRgZmbFV5ruBpiZWXM40M3MWoQD3cysRTjQzcxahAPdzKxFONDNzFqEA92OSJK+KOnvp7sdZs3kQLcZR9K1knokDUj6etW0CyT9eIrb83VJf9Uq67HW1TbdDTDL8Wvgr4APArOnuS1mheEjdJtxIuK7EfEAsG2sekp8VdJWSbskPSPpHTXqnizpnyXtlrQGWFw1/TuSXpW0U9Kjkt6elq8E/gj4M0n9kr6fll8v6YV0eRsk/X5mWaek69op6XVJ92amnSZpjaTtkp6T9B/GWo/ZePgI3QolIn4MXJCOfgB4H/A2YCdwGvBGjVn/AfhZOs95wD8C38tMfwj4JLAf+DLwTeCMiFgl6beATRHxl5n6LwC/DbwKfAj4e0mnRMQW4L8BPwL+HdABdANImgusAW4ELgHeCayR9OwY6zFrmI/QrcgOAPNJglwRsTEN1AqSlgPnAP81IgYi4lGg4gg4Iu6MiN0RMQB8EXi3pKNqrTgivhMRv46I4Yi4F3geODfTrpOAEyJiX0T8JC2/DHgpIv4uIgYj4hfA/SRfCGaHzYFuhRURDwO3ALcCWyWtkrQgp+oJwI6IeDNT9vLIgKSypL9Ou1B2AS+lkyq6ZbIkXS1pnaQ3JL0BvCNT/88AAY9LWi/pk2n5ScB5I/Ok8/0RcPx4t90sjwPdCi0ibo6Is4HTSbpe/ktOtS3A0WmXx4jlmeGPAFcA/x44CliRlmtkNdmFSToJ+FvgWmBRRCwEnh2pHxGvRsQfR8QJwJ8A/1vSKcArwD9HxMLMa15EfCZvPWbj5UC3GUdSm6RZQBkoS5ol6ZDzPZLOkXSepHbgTWAfMFxdLyJeBnqAL0nqkPRe4HczVeYDAyQnYecA/71qEa8Bb8mMzyUJ3760HZ8gOUIfadeHJJ2Yju5I6w4DPwDeJuljktrT1zmSfqPGeszGxYFuM9FfAnuB64GPpsN5JwoXkBwp7yDpQtkG/M8ay/wIycnQ7cAXgLsz0+5O598MbAAeq5r3DuD0tJvkgYjYAPwNyUnW10hObv40U/8cYK2kfmA1cF1EvBgRu0lOyl5F8tPMV0lOwHbmrafGdpjVJD/gwsysNfgI3cysRTjQzcxahAPdzKxFONDNzFrEtF36v3jx4lixYsV0rd7MrJCeeOKJ1yOiK2/atAX6ihUr6Onpma7Vm5kVkqSXa01ruMslvTz6F5J+kDOtU9K9knolrZW0YmJNNTOziRpPH/p1wMYa0z5Fcq+MU4CvklwsYWZmU6ihQE8vY/4d4PYaVa4A7kqH7wPeL0k16pqZ2SRo9Aj9f5HcQe6Q+2SklpLceIiIGCS5N/Wi6kqSVqaPFuvp6+ubQHPNzKyWuoEu6TJga0Q8cbgri4hVEdEdEd1dXbknac3MbIIaOUJ/D3C5pJeAe4ALc56WvhlYBsmd8khuQTrm48PMzKy56gZ6RNwQESdGxAqSu8Q9HBEfraq2GrgmHb4yreO7fpmZTaEJXykq6SZJl6ejdwCLJPUC/4nktqeT4pev7eYrP3qO1/sHJmsVZmaFNK4Li9IH9P44Hb4xU76PKXou4vOv9XPzw71c9u4TWDyvs/4MZmZHCN/LxcysRTjQzcxahAPdzKxFFDbQ/RsaM7NKhQt031DAzCxf4QLdzMzyOdDNzFpEYQM9cCe6mVlW4QLdXehmZvkKF+hmZpbPgW5m1iIc6GZmLaKwge4Li8zMKhUu0H1hkZlZvsIFupmZ5XOgm5m1iMIGuvvQzcwq1Q10SbMkPS7pKUnrJX0pp87HJfVJWpe+Pj05zQVfWmRmlq+RR9ANABdGRL+kduAnkh6KiMeq6t0bEdc2v4lmZtaIuoEeEQH0p6Pt6csdHmZmM0xDfeiSypLWAVuBNRGxNqfaH0h6WtJ9kpbVWM5KST2Sevr6+g6j2WZmVq2hQI+IoYg4AzgROFfSO6qqfB9YERHvAtYAd9VYzqqI6I6I7q6ursNpt++2aGZWZVy/comIN4BHgIuryrdFxEA6ejtwdnOadyhfWGRmlq+RX7l0SVqYDs8GLgL+tarOkszo5cDGZjbSzMzqa+RXLkuAuySVSb4Avh0RP5B0E9ATEauBz0m6HBgEtgMfn6wGm5lZvkZ+5fI0cGZO+Y2Z4RuAG5rbtHrtmsq1mZnNfIW7UtRd6GZm+QoX6GZmls+BbmbWIhzoZmYtwoFuZtYiChfo8pVFZma5ChfoZmaWz4FuZtYiChvovrDIzKxS4QLdPehmZvkKF+hmZpbPgW5m1iIc6GZmLaKwge4nFpmZVSpcoPu6IjOzfIULdDMzy+dANzNrEY08U3SWpMclPSVpvaQv5dTplHSvpF5JayWtmIzGZvnCIjOzSo0coQ8AF0bEu4EzgIslnV9V51PAjog4Bfgq8OXmNvMg96GbmeWrG+iR6E9H29NX9fHxFcBd6fB9wPvl2yKamU2phvrQJZUlrQO2AmsiYm1VlaXAKwARMQjsBBY1s6FmZja2hgI9IoYi4gzgROBcSe+YyMokrZTUI6mnr69vIoswM7MaxvUrl4h4A3gEuLhq0mZgGYCkNuAoYFvO/Ksiojsiuru6uibW4pFlHdbcZmatp5FfuXRJWpgOzwYuAv61qtpq4Jp0+Erg4YjJ+R2KfL9FM7NcbQ3UWQLcJalM8gXw7Yj4gaSbgJ6IWA3cAXxDUi+wHbhq0lpsZma56gZ6RDwNnJlTfmNmeB/woeY2zczMxqOwV4pOUo+OmVlhFS/Q3YVuZpareIFuZma5HOhmZi3CgW5m1iIKG+g+JWpmVqlwge5zomZm+QoX6GZmls+BbmbWIhzoZmYtorCB7gtFzcwqFS7Q/SAkM7N8hQt0MzPL50A3M2sRBQ50d6KbmWUVLtDdg25mlq9wgW5mZvkaeaboMkmPSNogab2k63LqXCBpp6R16evGvGWZmdnkaeSZooPAn0bEk5LmA09IWhMRG6rq/UtEXNb8JpqZWSPqHqFHxJaIeDId3g1sBJZOdsPq8YVFZmaVxtWHLmkFyQOj1+ZM/k1JT0l6SNLbm9C2Gm2YrCWbmRVbI10uAEiaB9wPfD4idlVNfhI4KSL6JV0KPACcmrOMlcBKgOXLl0+40WZmdqiGjtAltZOE+Tcj4rvV0yNiV0T0p8MPAu2SFufUWxUR3RHR3dXVdZhNNzOzrEZ+5SLgDmBjRHylRp3j03pIOjdd7rZmNrSau9DNzCo10uXyHuBjwDOS1qVlfw4sB4iI24Argc9IGgT2AldFTM5pS/nSIjOzXHUDPSJ+Qp0LNCPiFuCWZjXKzMzGz1eKmpm1CAe6mVmLKGyg+8IiM7NKhQt0X1hkZpavcIFuZmb5HOhmZi2isIE+ST9zNzMrrMIFurvQzczyFS7QzcwsnwPdzKxFONDNzFpEYQPdp0TNzCoVL9B9VtTMLFfxAt3MzHI50M3MWkRhA93XFZmZVSpcoPuJRWZm+Rp5pugySY9I2iBpvaTrcupI0s2SeiU9LemsyWmumZnV0sgzRQeBP42IJyXNB56QtCYiNmTqXAKcmr7OA76WvpuZ2RSpe4QeEVsi4sl0eDewEVhaVe0K4O5IPAYslLSk6a01M7OaxtWHLmkFcCawtmrSUuCVzPgmDg39pgpfWmRmVqHhQJc0D7gf+HxE7JrIyiStlNQjqaevr28ii/ATi8zMamgo0CW1k4T5NyPiuzlVNgPLMuMnpmUVImJVRHRHRHdXV9dE2mtmZjU08isXAXcAGyPiKzWqrQauTn/tcj6wMyK2NLGdZmZWRyO/cnkP8DHgGUnr0rI/B5YDRMRtwIPApUAvsAf4RPObWsVd6GZmFeoGekT8hDq3xIrkeXCfbVajxuIudDOzfIW7UtTMzPI50M3MWoQD3cysRRQ20H1O1MysUuECXb6yyMwsV+EC3czM8jnQzcxaRGED3U8sMjOrVLhAdxe6mVm+wgW6mZnlc6CbmbUIB7qZWYsobKD7iUVmZpUKF+g+J2pmlq9wgW5mZvkc6GZmLcKBbmbWIhp5puidkrZKerbG9Ask7ZS0Ln3d2PxmHspXipqZVWrkmaJfB24B7h6jzr9ExGVNaVEdvlLUzCxf3SP0iHgU2D4FbTEzs8PQrD7035T0lKSHJL29Scs0M7NxaKTLpZ4ngZMiol/SpcADwKl5FSWtBFYCLF++/LBW6i50M7NKh32EHhG7IqI/HX4QaJe0uEbdVRHRHRHdXV1dE1yjO9HNzPIcdqBLOl7pc+EknZsuc9vhLtfMzManbpeLpG8BFwCLJW0CvgC0A0TEbcCVwGckDQJ7gasi/KNCM7OpVjfQI+LDdabfQvKzRjMzm0aFvVLU/wkwM6tUuED3hUVmZvkKF+hmZpbPgW5m1iIKG+juQTczq1S4QHcXuplZvsIFupmZ5XOgm5m1CAe6mVmLKG6g+6yomVmFwgW6fGWRmVmuwgW6mZnlc6CbmbWIwgZ6uBPdzKxC4QLdPehmZvkKF+hmZpbPgW5m1iLqBrqkOyVtlfRsjemSdLOkXklPSzqr+c00M7N6GjlC/zpw8RjTLwFOTV8rga8dfrPq8wOLzMwq1Q30iHgU2D5GlSuAuyPxGLBQ0pJmNbCarysyM8vXjD70pcArmfFNaZmZmU2hKT0pKmmlpB5JPX19fVO5ajOzlteMQN8MLMuMn5iWHSIiVkVEd0R0d3V1HdZK3YduZlapGYG+Grg6/bXL+cDOiNjShOXmaislTR4cdqKbmWW11asg6VvABcBiSZuALwDtABFxG/AgcCnQC+wBPjFZjQVoLydnRQ8MDU/maszMCqduoEfEh+tMD+CzTWtRHe3l5AjdgW5mVqlwV4q2t6VdLkPucjEzyypeoKddLvt9hG5mVqFwgd7hLhczs1yFC3T3oZuZ5StwoLsP3cwsq4CBnvahD/oI3cwsq3CBLom2knxS1MysSuECHWBWe5mBAw50M7OsQgb6nI4ye/YPTnczzMxmlEIG+tzONt7cPzTdzTAzm1EKGuhl9gz4CN3MLKuQgT6no4033eViZlahkIE+t6PMmwPucjEzyypkoM/p9BG6mVm1Qgb63I4ye3yEbmZWoZCBPn9WO7v2HZjuZpiZzSiFDPRF8zrYs3/Iv0U3M8toKNAlXSzpOUm9kq7Pmf5xSX2S1qWvTze/qQctntcJwOu790/maszMCqWRZ4qWgVuBi4BNwM8lrY6IDVVV742IayehjYfoSgO9r3+A5YvmTMUqzcxmvEaO0M8FeiPixYjYD9wDXDG5zRrb6BF6/8B0NsPMbEZpJNCXAq9kxjelZdX+QNLTku6TtKwprathycJZSUN27J3M1ZiZFUqzTop+H1gREe8C1gB35VWStFJSj6Sevr6+Ca9s0dwOjprdzot9/RNehplZq2kk0DcD2SPuE9OyURGxLSJG+j9uB87OW1BErIqI7ojo7urqmkh7geSe6G/tmssLDnQzs1GNBPrPgVMlnSypA7gKWJ2tIGlJZvRyYGPzmpjv1GPn89yruxke9qPozMyggUCPiEHgWuCHJEH97YhYL+kmSZen1T4nab2kp4DPAR+frAaPOHvF0ezYc4BeH6WbmQEN/GwRICIeBB6sKrsxM3wDcENzmza2804+BoCfvbCNtx03fypXbWY2IxXySlGA5cfM4a1dc/nHZ7ZMd1PMzGaEwga6JH7vjKU8/qvtvPT6m9PdHDOzaVfYQAf4w3OW0dlW4tZHeqe7KWZm067QgX7sgll89PyTuP/JTTzx8vbpbo6Z2bQqdKAD/MeL3sYJC2dz3T3r2Lp733Q3x8xs2hQ+0Od1tnHrR85i+5v7+ejta9m0Y890N8nMbFoUPtAB3r1sIbdf3c2Wnfu4/JafsvqpXxPhC47M7MjSEoEO8FunLOaBz76HpQtn87lv/YIrb/sZaza8xpCvJDWzI4Sm60i2u7s7enp6mr7coeHgnp//G1/78Qts2rGXY+d38jvvWsJFv3EcZ510NLPay01fp5nZVJH0RER0505rtUAfMTg0zJoNr/G9db/m4ee2sn9wmI62EmcuW8gZyxZy+gkLOH3JAk5ePJe2csv8R8XMWtxYgd7Qpf9F1FYucck7l3DJO5fQPzDI47/axv/r3cbaX23n7376EvuHhgFoL4ulC2ezfNFcTjpmDsuPmcNxR82ia14nXfM7OXZBJ/M725A0zVtkZja2lg30rHmdbVx42nFceNpxABwYGuaFvn7Wb97FC339vLx9D/+2bQ9PvfIGO/ceOGT+zrYSXfM7OWp2+yGvBSOvWW3M7WhjTkeZ2R1l5na2Mbu9zJx0uLOt5C8FM5tUR0SgV2svlzjt+AWcdvyCQ6bt3HuAvt372LprgL7+gdH3vt0D7Nx7gJ17D/D81v7R4f2Dww2tsySSgE+DvqOtRGdbiY62Eh3lEp3t5eQ9Wz46rURH+eA87WXRVi7RVhJtZdFWSstKJcpl0V4qpeU16o2UVU1vL5UolfylY1ZUR2Sgj2XkyPuUYxu7g+O+A0Ps2nuAXfsOsGf/UPoaHB3em1O278AQ+weHGRgcYmBwmIHBYXalXw4Dg0PsHxpOhw++T+WvdcolUZYolUjfNVomiXJOeSn7nk5P6maWVRIlHTpPuZQMl0TVspJ79ggoKZkuCWmMcQ6Wl0anHTpeStuXLBtKJeWs6+B8I+Mj8x26roPvI+upGAdI55Fg5GtzpP0iWT5kxzVaPjIfVeOqWmatZVTPNzqes468tlbXY3TdOdNG25HXvkxd/4+16Rzoh2lWe5lZ7WWOXTBrUtczNByjgX9gKBgcHmZwKBgcDgaHhjkwFAwNBwdGyw++j04bSsoq6yXzD6bTh4eDoQiGhmE4krpDw8FwRDrOaJ2DdSNT9+B8B+cJhoeTrq7KupnpkZkvXW4EDAdEBEEyfXg4KR8dT+tFZMZJxq0YxvzSoMYXBQe/EEa/FnK+KLPTq7/cRqYeWm/s9VW0e3T62OujajlXnbOMT//2W+rum/FyoBdEuSRmp/3zVl+MfiEc/DIYHR8N/8p6h3x51Jhe8U7yZTX6xcLBL6eReYeGD37JBOm3EVSUjXxJjayfbHnVtEgrHCw/dBlk1zcyPNY6cpZDZn3ZdeetI7uMtHUHh6PBdeS0JbO7qtbJ6HD1+irqZupl90V2/5OpObKfRpY51voq/x3z1pfTlrRw8bxOJoMD3VrSaFcMql/ZrEU09ANsSRdLek5Sr6Trc6Z3Sro3nb5W0opmN9TMzMZWN9AllYFbgUuA04EPSzq9qtqngB0RcQrwVeDLzW6omZmNrZEj9HOB3oh4MSL2A/cAV1TVuQK4Kx2+D3i/fArbzGxKNRLoS4FXMuOb0rLcOhExCOwEFjWjgWZm1pgpvYmJpJWSeiT19PX1TeWqzcxaXiOBvhlYlhk/MS3LrSOpDTgK2Fa9oIhYFRHdEdHd1dU1sRabmVmuRgL958Cpkk6W1AFcBayuqrMauCYdvhJ4OPyECTOzKVX3d+gRMSjpWuCHQBm4MyLWS7oJ6ImI1cAdwDck9QLbSULfzMym0LTdD11SH/DyBGdfDLzexOYUlfeD98EI74cjZx+cFBG5fdbTFuiHQ1JPrRu8H0m8H7wPRng/eB9ACz1T1MzsSOdANzNrEUUN9FXT3YAZwvvB+2CE94P3QTH70M3M7FBFPUI3M7MqDnQzsxZRuECvd2/2opP0kqRnJK2T1JOWHSNpjaTn0/ej03JJujndF09LOiuznGvS+s9LuqbW+mYKSXdK2irp2UxZ07Zb0tnpfu1N551xdwOtsQ++KGlz+nlYJ+nSzLQb0u15TtIHM+W5fyPp1d5r0/J70yu/ZxRJyyQ9ImmDpPWSrkvLj6jPwoTF6KOyZv6L5ErVF4C3AB3AU8Dp092uJm/jS8DiqrL/AVyfDl8PfDkdvhR4iORRhecDa9PyY4AX0/ej0+Gjp3vb6mz3+4CzgGcnY7uBx9O6Sue9ZLq3ucF98EXgP+fUPT39/HcCJ6d/F+Wx/kaAbwNXpcO3AZ+Z7m3O2a4lwFnp8Hzgl+m2HlGfhYm+inaE3si92VtR9n7zdwG/lym/OxKPAQslLQE+CKyJiO0RsQNYA1w81Y0ej4h4lOS2EVlN2e502oKIeCySv+i7M8uaMWrsg1quAO6JiIGI+BXQS/L3kfs3kh6FXkjyvAKo3J8zRkRsiYgn0+HdwEaS23MfUZ+FiSpaoDdyb/aiC+BHkp6QtDItOy4itqTDrwLHpcO19ker7KdmbffSdLi6vCiuTbsT7hzpamD8+2AR8EYkzyvIls9YSh5leSawFn8WGlK0QD8SvDciziJ55N9nJb0vOzE9qjjifmt6pG438DXgrcAZwBbgb6a3OVND0jzgfuDzEbErO+0I/izUVbRAb+Te7IUWEZvT963A/yH5L/Rr6X8VSd+3ptVr7Y9W2U/N2u7N6XB1+YwXEa9FxFBEDAN/S/J5gPHvg20k3RFtVeUzjqR2kjD/ZkR8Ny0+4j8LjShaoDdyb/bCkjRX0vyRYeADwLNU3m/+GuB76fBq4Or0TP/5wM70v6U/BD4g6ej0v+gfSMuKpinbnU7bJen8tC/56syyZrSREEv9PsnnAZJ9cJWkTkknA6eSnOzL/RtJj2ofIXleAVTuzxkj/fe5A9gYEV/JTDriPwsNme6zsuN9kZzV/iXJmfy/mO72NHnb3kLyq4SngPUj20fS//l/geeBfwKOScsF3Jrui2eA7syyPklyoqwX+MR0b1sD2/4tki6FAyT9mp9q5nYD3SRh+AJwC+lV0jPpVWMffCPdxqdJwmtJpv5fpNvzHJlfatT6G0k/X4+n++Y7QOd0b3POPngvSXfK08C69HXpkfZZmOjLl/6bmbWIonW5mJlZDQ50M7MW4UA3M2sRDnQzsxbhQDczaxEOdDOzFuFANzNrEf8fTLdmNok3ocMAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zzgjNw0VHsxm" + }, + "source": [ + "# Accuracy Finding" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ecNjPxdyHzeW" + }, + "source": [ + "Running test in each row (each traing examples)\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "sbg91GKJjXWy" + }, + "source": [ + "Theeta = [Theeta0,Theeta1,Theeta2,Theeta3,Theeta4,Theeta5,Theeta6,Theeta7,Theeta8,Theeta9]" + ], + "execution_count": 361, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VSSQPq95cv45", + "outputId": "79a1bfce-52e5-4159-e2e3-668c7ac81dd8" + }, + "source": [ + "for n in range(10):\n", + " correct_predictions = 0 \n", + " for i in range(19999):\n", + " if y_train[i]==n:\n", + " y_train[i]=1\n", + " else:\n", + " y_train[i]=0\n", + " temp = Theeta[n]\n", + " g_temp = np.dot(temp,x_n_train[i])\n", + " hypothesis = 1/(1+np.exp(-g_temp))\n", + " \n", + " if hypothesis >= 0.5:\n", + " hypothesis = 1\n", + " else:\n", + " hypothesis = 0\n", + " \n", + " if hypothesis == y_train[i]:\n", + " correct_predictions+=1\n", + " \n", + " print(correct_predictions,'for Digit',n)" + ], + "execution_count": 362, + "outputs": [ + { + "output_type": "stream", + "text": [ + "1984 for Digit 0\n", + "1981 for Digit 1\n", + "18013 for Digit 2\n", + "17982 for Digit 3\n", + "18010 for Digit 4\n", + "18008 for Digit 5\n", + "18004 for Digit 6\n", + "17996 for Digit 7\n", + "18010 for Digit 8\n", + "17998 for Digit 9\n" + ], + "name": "stdout" + } + ] + } + ] +} \ No newline at end of file From 61401a516b3e94f364b084c4051713835c75c704 Mon Sep 17 00:00:00 2001 From: Vivek Patidar <77988917+vivekpatidar1413@users.noreply.github.com> Date: Sat, 10 Apr 2021 14:32:11 +0530 Subject: [PATCH 2/4] Created using Colaboratory --- LogisticRegression_using_sklearn.ipynb | 322 +++++++++++++++++++++++++ 1 file changed, 322 insertions(+) create mode 100644 LogisticRegression_using_sklearn.ipynb diff --git a/LogisticRegression_using_sklearn.ipynb b/LogisticRegression_using_sklearn.ipynb new file mode 100644 index 0000000..6aeca05 --- /dev/null +++ b/LogisticRegression_using_sklearn.ipynb @@ -0,0 +1,322 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "LogisticRegression_using_sklearn.ipynb", + "provenance": [], + "collapsed_sections": [], + "authorship_tag": "ABX9TyOtM49g4w7FsFaObK58Q3yS", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "SqzbeIzSIBZE" + }, + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.metrics import accuracy_score" + ], + "execution_count": 8, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "RTvWtumslXXF" + }, + "source": [ + "train_df = pd.read_csv(\"/content/sample_data/mnist_train_small.csv\")\n", + "test_df = pd.read_csv(\"/content/sample_data/mnist_test.csv\")" + ], + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "leL1lkgrlbMg" + }, + "source": [ + "train = train_df.to_numpy()\n", + "test = test_df.to_numpy()" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "VYypfC6jmPjU" + }, + "source": [ + "x_train = train[:,1:]\n", + "y_train = train[:,:1]\n", + "\n", + "x_test = test[:,1:]\n", + "y_test = test[:,:1]" + ], + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "--IDYK8h8uXF" + }, + "source": [ + "clf = LogisticRegression()\n", + "acc = []" + ], + "execution_count": 46, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Ryge9cfM8whg" + }, + "source": [ + "def one_vs_all(y_train,y_test,label):\n", + "\n", + " y_train_new = np.zeros((19999,1))\n", + " y_test_new = np.zeros((9999,1))\n", + "\n", + " for i in range(19999):\n", + " if y_train[i] == label:\n", + " y_train_new [i]= 1\n", + "\n", + "\n", + " for i in range(9999):\n", + " if y_test[i] == label:\n", + " y_test_new[i] = 1\n", + "\n", + "\n", + " return y_train_new,y_test_new" + ], + "execution_count": 47, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "CfffvqOw4Nuv", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "bd369552-bb43-41db-cb47-7e4cc8270683" + }, + "source": [ + "for i in range(10):\n", + " y_train_new,y_test_new = one_vs_all(y_train,y_test,i)\n", + " clf.fit(x_train, y_train_new)\n", + "\n", + " y_pred = clf.predict(x_test)\n", + " accuracy = accuracy_score(y_pred,y_test_new)\n", + " \n", + " acc.append(accuracy)\n" + ], + "execution_count": 48, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " y = column_or_1d(y, warn=True)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " y = column_or_1d(y, warn=True)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " y = column_or_1d(y, warn=True)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " y = column_or_1d(y, warn=True)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " y = column_or_1d(y, warn=True)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " y = column_or_1d(y, warn=True)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " y = column_or_1d(y, warn=True)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " y = column_or_1d(y, warn=True)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " y = column_or_1d(y, warn=True)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " y = column_or_1d(y, warn=True)\n", + "/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n" + ], + "name": "stderr" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ib2a_a_r8yOB", + "outputId": "a1f71aa8-3c3e-49bd-ffef-8ba1ccb450e5" + }, + "source": [ + "for i in range(10):\n", + " print('the accuracy for the digit',i,'is ',acc[i]*100,'%')" + ], + "execution_count": 51, + "outputs": [ + { + "output_type": "stream", + "text": [ + "the accuracy for the digit 0 is 98.55985598559856 %\n", + "the accuracy for the digit 1 is 98.79987998799879 %\n", + "the accuracy for the digit 2 is 97.7897789778978 %\n", + "the accuracy for the digit 3 is 97.22972297229722 %\n", + "the accuracy for the digit 4 is 97.91979197919792 %\n", + "the accuracy for the digit 5 is 97.3097309730973 %\n", + "the accuracy for the digit 6 is 98.08980898089808 %\n", + "the accuracy for the digit 7 is 97.92979297929793 %\n", + "the accuracy for the digit 8 is 94.3994399439944 %\n", + "the accuracy for the digit 9 is 95.96959695969596 %\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Z6LyPXr7ASGD" + }, + "source": [ + "The mean Accuracy" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "USCDDg-a_r6G", + "outputId": "6a2b9cbd-a9f9-4c4c-eb9c-bbe4f71858a7" + }, + "source": [ + "# let the overall accuracy be the mean of all the individul accuarcy\n", + "\n", + "mean_accuracy = sum(acc)/10\n", + "\n", + "print('THE ACCURACY IS',mean_accuracy*100,'%')" + ], + "execution_count": 54, + "outputs": [ + { + "output_type": "stream", + "text": [ + "THE ACCURACY IS 97.39973997399738 %\n" + ], + "name": "stdout" + } + ] + } + ] +} \ No newline at end of file From 292fe2a04d8277da0eba42181e565e74d163aec4 Mon Sep 17 00:00:00 2001 From: Vivek Patidar <77988917+vivekpatidar1413@users.noreply.github.com> Date: Sat, 10 Apr 2021 15:41:49 +0530 Subject: [PATCH 3/4] Created using Colaboratory --- FINAL_LogisticRegression.ipynb | 1024 ++++++++++++++++++++++++++++++++ 1 file changed, 1024 insertions(+) create mode 100644 FINAL_LogisticRegression.ipynb diff --git a/FINAL_LogisticRegression.ipynb b/FINAL_LogisticRegression.ipynb new file mode 100644 index 0000000..1a7d2c0 --- /dev/null +++ b/FINAL_LogisticRegression.ipynb @@ -0,0 +1,1024 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "FINAL_LogisticRegression.ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true, + "authorship_tag": "ABX9TyO6JxHl6zAXYvtXj6wgQs0t", + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "osM8JPRAlth8" + }, + "source": [ + "# Importing The MNIST dataset\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "qaP_jRa_lFb6" + }, + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt" + ], + "execution_count": 109, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "RTvWtumslXXF" + }, + "source": [ + "train_df = pd.read_csv(\"/content/sample_data/mnist_train_small.csv\")\n", + "test_df = pd.read_csv(\"/content/sample_data/mnist_test.csv\")" + ], + "execution_count": 110, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GX-d4zh3JFJL" + }, + "source": [ + "converting the data frame into numpy array" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "leL1lkgrlbMg" + }, + "source": [ + "train = train_df.to_numpy()\n", + "test = test_df.to_numpy()" + ], + "execution_count": 111, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZVCA5mGRlfxH", + "outputId": "68371598-2e59-4a49-d3d8-1df17048d542" + }, + "source": [ + "print(train.shape)\n", + "print(train)" + ], + "execution_count": 112, + "outputs": [ + { + "output_type": "stream", + "text": [ + "(19999, 785)\n", + "[[5 0 0 ... 0 0 0]\n", + " [7 0 0 ... 0 0 0]\n", + " [9 0 0 ... 0 0 0]\n", + " ...\n", + " [2 0 0 ... 0 0 0]\n", + " [9 0 0 ... 0 0 0]\n", + " [5 0 0 ... 0 0 0]]\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zH4eRqDhrg_7" + }, + "source": [ + "# Reshaping the dataset into desired shape and Size" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "VYypfC6jmPjU" + }, + "source": [ + "x_train = train[:,1:]\n", + "y_train = train[:,:1]" + ], + "execution_count": 113, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "m3R9C7NzKQrN" + }, + "source": [ + "# Adding one more coloumn to x_train so we can take dot product of it with THEETA\n", + "\n", + "x_n_train = np.arange(19999*785)\n", + "x_n_train = np.reshape(x_n_train,(19999,785))\n", + "\n", + "for i in range(19999):\n", + " x_n_train[i] = np.insert(x_train[i],0,1)\n", + "x_n_train = x_n_train/255" + ], + "execution_count": 115, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rGjSX1j6mYxK", + "outputId": "c343b6bf-fa03-4a5d-c037-fa16136ba5a7" + }, + "source": [ + "print(y_train.shape)\n", + "print(x_n_train.shape)" + ], + "execution_count": 116, + "outputs": [ + { + "output_type": "stream", + "text": [ + "(19999, 1)\n", + "(19999, 785)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QO2-tBp5KaP_" + }, + "source": [ + "# THE MAIN FUNCTION" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "V0odI5uq0TMk", + "outputId": "214f995d-4d5e-441e-ee1d-c57ea6b3998e" + }, + "source": [ + "''' ONE VS ALL'''\n", + "# classifier" + ], + "execution_count": 117, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "' ONE VS ALL'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 117 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F5FudWz46l-Q" + }, + "source": [ + "Defining a function which we call for diffrent digit classification\n", + "\n", + "* input = taking the digit for which the classification is to be performed\n", + "* output = the values of theeta and cost function after every iteration\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yCcBbllQm1Zb" + }, + "source": [ + "def THE_MAIN_FUNCTION(n,X,Y):\n", + "\n", + " # Let the iterations be 50000\n", + " itrations = 50000\n", + " # let the learning rate be 0.16\n", + " alpha = 0.16\n", + " # the number of training set be m which is 19999 here\n", + " m = 19999\n", + "\n", + " '''Converting the Y_TRAIN in BINARY FORM'''\n", + " '''Y be 1 if the number is same as the digit to be trained(n)'''\n", + " '''Y be 0 if the number is not equal as the digit to be trained(n)'''\n", + " for i in range(19999):\n", + " if Y[i]==n:\n", + " Y[i]=1\n", + " else:\n", + " Y[i]=0\n", + "\n", + " y = Y.T\n", + " X = X.T\n", + " \n", + " # Intialising the array of theeta to be any random value \n", + " Theeta = np.random.randn(1,785)\n", + "\n", + " Cost_Function = []\n", + " k = 0\n", + "\n", + " print('TRAINING THE MODEL FOR DIGIT',n)\n", + "\n", + "\n", + " # The main itration loops bigins from here\n", + "\n", + " for i in range(1,itrations+1):\n", + " \n", + " g = np.dot(Theeta,X)\n", + " hypothesis = 1/(1 + np.exp(-g))\n", + "\n", + " # COST FUNCTION\n", + " j = 1/m*(-1*(np.sum(y*np.log(hypothesis) + (1-y)*np.log(1-hypothesis))))\n", + " Cost_Function.append(j)\n", + " \n", + " # GRADIENT DESCENT\n", + " dw = 1/m * np.dot(hypothesis-y,X.T)\n", + " Theeta = Theeta - alpha*dw\n", + " \n", + " k+=1\n", + "\n", + " if i%2500 == 0:\n", + " print(i,'th Iteration , Cost Function =',j)\n", + "\n", + "\n", + " # BREAKING THE LOOP\n", + " '''stoping the loop if the change in value of cost function is too low'''\n", + " if i%2 == 0:\n", + " if abs(j-Cost_Function[-2])<0.000001:\n", + " if abs(j-Cost_Function[-3])<0.000001:\n", + " break \n", + "\n", + " \n", + " print('Last itteration number:',k)\n", + "\n", + " return Theeta,Cost_Function" + ], + "execution_count": 118, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JeuONSUW9bs5", + "outputId": "9c99793e-bd50-4327-8bc3-756d6647999e" + }, + "source": [ + "y_train" + ], + "execution_count": 27, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[5],\n", + " [7],\n", + " [9],\n", + " ...,\n", + " [2],\n", + " [9],\n", + " [5]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 27 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "pBB__Gt7BbpS" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "pGwZsoqzBbl-" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "D4aRqZiv7XdB", + "outputId": "198f4068-cce9-4a9e-f993-808d28b5cec5" + }, + "source": [ + "Theeta0 , Cost_Function0 = THE_MAIN_FUNCTION (0,x_n_train,y_train)\n", + "Theeta1 , Cost_Function1 = THE_MAIN_FUNCTION (1,x_n_train,y_train)" + ], + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 0\n", + "2500 th Iteration , Cost Function = 0.06041040573278516\n", + "5000 th Iteration , Cost Function = 0.04906703014962782\n", + "7500 th Iteration , Cost Function = 0.04334372045004448\n", + "10000 th Iteration , Cost Function = 0.03961669775569828\n", + "12500 th Iteration , Cost Function = 0.03692579793340377\n", + "15000 th Iteration , Cost Function = 0.03486363878296964\n", + "17500 th Iteration , Cost Function = 0.033216712547757654\n", + "Last itteration number: 19868\n", + "TRAINING THE MODEL FOR DIGIT 1\n", + "2500 th Iteration , Cost Function = 0.057798215191868806\n", + "5000 th Iteration , Cost Function = 0.04604344257275115\n", + "7500 th Iteration , Cost Function = 0.040567038639967384\n", + "10000 th Iteration , Cost Function = 0.03704956712927097\n", + "12500 th Iteration , Cost Function = 0.034518325236555285\n", + "15000 th Iteration , Cost Function = 0.03259073449346777\n", + "17500 th Iteration , Cost Function = 0.03106556631225347\n", + "Last itteration number: 18644\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PCFnxnxk7XLX", + "outputId": "1578fdd5-c93d-4769-a00c-eaa819f96547" + }, + "source": [ + "Theeta2 , Cost_Function2 = THE_MAIN_FUNCTION (2,x_n_train,y_train)" + ], + "execution_count": 40, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 2\n", + "2500 th Iteration , Cost Function = 0.11931921583769352\n", + "5000 th Iteration , Cost Function = 0.0992087175142309\n", + "7500 th Iteration , Cost Function = 0.0896869124863076\n", + "10000 th Iteration , Cost Function = 0.08381462155248537\n", + "12500 th Iteration , Cost Function = 0.07981203397749509\n", + "15000 th Iteration , Cost Function = 0.07689319034301668\n", + "17500 th Iteration , Cost Function = 0.07465387600664779\n", + "20000 th Iteration , Cost Function = 0.07286869792335404\n", + "22500 th Iteration , Cost Function = 0.07140309191857962\n", + "Last itteration number: 23494\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CFF8nJEU7vDh", + "outputId": "f1edeb5a-e292-43dc-b68a-fae47c0f9ff3" + }, + "source": [ + "Theeta3 , Cost_Function3 = THE_MAIN_FUNCTION (3,x_n_train,y_train)" + ], + "execution_count": 52, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 3\n", + "2500 th Iteration , Cost Function = 0.13563987952445228\n", + "5000 th Iteration , Cost Function = 0.11326294321733435\n", + "7500 th Iteration , Cost Function = 0.10369498460352018\n", + "10000 th Iteration , Cost Function = 0.0982525261152735\n", + "12500 th Iteration , Cost Function = 0.0946418881512357\n", + "15000 th Iteration , Cost Function = 0.09202214704496718\n", + "17500 th Iteration , Cost Function = 0.09001092973888837\n", + "20000 th Iteration , Cost Function = 0.08840623843657527\n", + "Last itteration number: 21932\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "_XLJ8odN7XC3", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "98eac3e0-c86c-4ad6-d980-9cfb367250ca" + }, + "source": [ + "Theeta4 , Cost_Function4 = THE_MAIN_FUNCTION (4,x_n_train,y_train)" + ], + "execution_count": 64, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 4\n", + "2500 th Iteration , Cost Function = 0.09369559173311176\n", + "5000 th Iteration , Cost Function = 0.07839983681276079\n", + "7500 th Iteration , Cost Function = 0.07069005748541593\n", + "10000 th Iteration , Cost Function = 0.06579064446646775\n", + "12500 th Iteration , Cost Function = 0.06235889497377829\n", + "15000 th Iteration , Cost Function = 0.05979265899653366\n", + "17500 th Iteration , Cost Function = 0.05777933742662985\n", + "20000 th Iteration , Cost Function = 0.0561437349616969\n", + "22500 th Iteration , Cost Function = 0.054780942004905187\n", + "Last itteration number: 22514\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "igbj9cia97Z9", + "outputId": "abdb7d0d-bf59-4fbc-9622-dedf0cd0cf5b" + }, + "source": [ + "Theeta5 , Cost_Function5 = THE_MAIN_FUNCTION (5,x_n_train,y_train)" + ], + "execution_count": 75, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 5\n", + "2500 th Iteration , Cost Function = 0.14014545445448723\n", + "5000 th Iteration , Cost Function = 0.11585745188799228\n", + "7500 th Iteration , Cost Function = 0.10446644668829982\n", + "10000 th Iteration , Cost Function = 0.09774459603162665\n", + "12500 th Iteration , Cost Function = 0.09325878474237423\n", + "15000 th Iteration , Cost Function = 0.09001798386785721\n", + "17500 th Iteration , Cost Function = 0.08754393890989463\n", + "20000 th Iteration , Cost Function = 0.08557763313809627\n", + "22500 th Iteration , Cost Function = 0.08396687161114089\n", + "Last itteration number: 24918\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "UthB_T3L7W8o", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "c43e3388-5ac8-451a-a911-b4c66f12e6d3" + }, + "source": [ + "Theeta6 , Cost_Function6 = THE_MAIN_FUNCTION (6,x_n_train,y_train)" + ], + "execution_count": 86, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 6\n", + "2500 th Iteration , Cost Function = 0.0741880252988771\n", + "5000 th Iteration , Cost Function = 0.0631830742142477\n", + "7500 th Iteration , Cost Function = 0.05721118582331882\n", + "10000 th Iteration , Cost Function = 0.05314238468015187\n", + "12500 th Iteration , Cost Function = 0.05013624184749069\n", + "15000 th Iteration , Cost Function = 0.047809392369757585\n", + "17500 th Iteration , Cost Function = 0.04595018886892197\n", + "20000 th Iteration , Cost Function = 0.044428419573251735\n", + "Last itteration number: 21456\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QZky9LvXFuhv", + "outputId": "98cf4b1e-3da2-4fc7-c39e-023c5743b68f" + }, + "source": [ + "Theeta7 , Cost_Function7 = THE_MAIN_FUNCTION (7,x_n_train,y_train)" + ], + "execution_count": 97, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 7\n", + "2500 th Iteration , Cost Function = 0.07930303222290891\n", + "5000 th Iteration , Cost Function = 0.06641028884497935\n", + "7500 th Iteration , Cost Function = 0.06064199643542249\n", + "10000 th Iteration , Cost Function = 0.05705538981758584\n", + "12500 th Iteration , Cost Function = 0.05453111427980209\n", + "15000 th Iteration , Cost Function = 0.0526372608708086\n", + "17500 th Iteration , Cost Function = 0.05115362212772595\n", + "Last itteration number: 18228\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "KCb4VacsOM6R", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "89aae907-185b-4a87-81f0-92950966361f" + }, + "source": [ + "Theeta8 , Cost_Function8 = THE_MAIN_FUNCTION (8,x_n_train,y_train)" + ], + "execution_count": 108, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 8\n", + "2500 th Iteration , Cost Function = 0.2036883546879894\n", + "5000 th Iteration , Cost Function = 0.17645506540909262\n", + "7500 th Iteration , Cost Function = 0.16506922369701954\n", + "10000 th Iteration , Cost Function = 0.15848603286749735\n", + "12500 th Iteration , Cost Function = 0.15421689969572153\n", + "15000 th Iteration , Cost Function = 0.15125635470607918\n", + "17500 th Iteration , Cost Function = 0.14909672983687638\n", + "20000 th Iteration , Cost Function = 0.14745489878577617\n", + "Last itteration number: 21584\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "K-N4m-Y8KWY4", + "outputId": "0cf5cd8b-af01-4726-cfe5-db91431b0f5f" + }, + "source": [ + "Theeta9 , Cost_Function9 = THE_MAIN_FUNCTION (9,x_n_train,y_train)" + ], + "execution_count": 119, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TRAINING THE MODEL FOR DIGIT 9\n", + "2500 th Iteration , Cost Function = 0.16500943623869507\n", + "5000 th Iteration , Cost Function = 0.14141752756850529\n", + "7500 th Iteration , Cost Function = 0.13058051904279028\n", + "10000 th Iteration , Cost Function = 0.12409200352512417\n", + "12500 th Iteration , Cost Function = 0.11969857147976186\n", + "15000 th Iteration , Cost Function = 0.11652089048077316\n", + "17500 th Iteration , Cost Function = 0.11412162917690935\n", + "20000 th Iteration , Cost Function = 0.11225052002200168\n", + "22500 th Iteration , Cost Function = 0.1107527723782374\n", + "Last itteration number: 23460\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZcTVHYnrHmyw" + }, + "source": [ + "# Graph Ploting for Cost Function" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JbOYoSAtLLex" + }, + "source": [ + "Graph Showing the decresing nature of cost function \n", + "\n", + "* number of iterations on x-axis\n", + "* cost function value on y-axis\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Edo3gOe8ERVs", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "a88ff1bf-f45f-4b97-dacb-1a872d73caf3" + }, + "source": [ + "plt.plot(Cost_Function0)\n", + "plt.title(\"0's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function1)\n", + "plt.title(\"1's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function2)\n", + "plt.title(\"2's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function3)\n", + "plt.title(\"3's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function4)\n", + "plt.title(\"4's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function5)\n", + "plt.title(\"5's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function6)\n", + "plt.title(\"6's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function7)\n", + "plt.title(\"7's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function8)\n", + "plt.title(\"8's dataset\")\n", + "plt.show()\n", + "plt.plot(Cost_Function9)\n", + "plt.title(\"9's dataset\")\n", + "plt.show()" + ], + "execution_count": 120, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAEICAYAAAB25L6yAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAVyElEQVR4nO3deZCkdX3H8c+nu+fYY9iDHTa7XAsilBtLhIwURjQVTBAQz1gJWkY8qjYxQTHRMqAVi/iHFXNYmigmq6AYD4KCEYlyaDgkkWMWARcQ2IXlWJfdWdhlD/ea6W/+eJ6e6Z7unuldpmd+M/N+VXX107/n18/z7d/2fPrZ5+mnH0eEAADpKkx1AQCAsRHUAJA4ghoAEkdQA0DiCGoASBxBDQCJI6gxo9h+r+07proOYCIR1Jg0tlfY/pHtbbaftf1F26WqeRsmuZ5LbX9zpqwHMxdBjcl0maQtkpZJeqWk35P0F1NaETANENSYTMdJujoi9kbEs5JukPTbjTra/hvbG23vtP2I7dc36Xe47ets77B9t6SXjJr/BdtP5/PX2H5t3n62pE9I+hPbu2zfn7e/z/bD+Xoft/1nVctaYvt629ttP2/7Z7YL+bzltq+xPWD7CdsfHms9wMEoTXUBmFU+L+l827dKWiTpHEl/K0kRsUHSCkmyfZKkCyW9KiJ+bXuFpGKTZX5J0l5lW+nHSbpR0hNV8++R9GlJL0i6SNJ3ba+IiBtsf0bSCRHx7qr+WySdJ+lxSa+T9GPb90TEvZI+KukZSb1539MlRR7WP5T0A0nvlHSUpJ/YfmSM9QAtY4sak+l2ZVvQO5QFXr+k/2rQb0hSl6SVtjsiYkNErB/dyXZR0h9J+lRE7I6ItZKurO4TEd+MiOciYjAi/jlf7knNCoyI/46I9ZG5TdJNkl6bzz6g7APh2Ig4EBE/i+zHcl4lqTciPh0R+yPicUlfkXR+60MDNEdQY1LkW503SLpW0jxJS5RtVX92dN+IWCfpI5IulbTF9lW2lzdYbK+y/xU+XdX25Kj1fizflfGC7e2SFuTrblbnObbvzHdtbJd0blX/f5S0TtJN+W6Ri/P2YyUtz3eJbM+f9wlJS8cYEqBlBDUmy2JJx0j6YkTsi4jnJH1NWRDWiYhvR8QZykIw1CDQJQ1IGpR0dFXbMZWJfH/0xyX9saRFEbFQ2S4QV1ZTvTDbXZKukfRPkpbm/X9U6R8ROyPioxFxvKQ3S/rrfN/505KeiIiFVbeeiDi30XqAg0VQY1JExFZl+44/aLtke6GkCyQ9MLqv7ZNsn5kH515JeySVGyxzSNkW+qW259pemS+zokdZkA9IKtn+lKTDquZvlrSickBQUqeyXSMDkgZtnyPprKq6zrN9gm0rC/yhvK67Je3MD4DOsV20/XLbr2qyHuCg8MbBZHq7pLOVBeE6Zft8/6pBvy5Jfy9pq6RnJR0h6ZImy7xQ0vy839eVbaVX3Khsd8ujynaJ7FXtbpLv5vfP2b43InZK+rCkqyVtk/QuSddV9X+ppJ9I2iXp55Iui4hb8g+M85R95fCJvO6vKtvNUreeJq8DaMpcOAAA0sYWNQAkjqAGgMQR1ACQOIIaABLXllPIlyxZEitWrGjHogFgRlqzZs3WiOhtNK8tQb1ixQr19/e3Y9EAMCPZfrLZvJZ2fdheaPt7tn+Vn4776okrDwAwlla3qL8g6YaIeIftTklz21gTAKDKuEFte4Gyn3t8ryRFxH5J+9tbFgCgopVdH8cpO+X3a7Z/YfurtueN7mR7le1+2/0DAwMTXigAzFatBHVJ0qmSvhwRp0jaLeni0Z0iYnVE9EVEX29vwwOXAIBD0EpQPyPpmYi4K3/8PWXBDQCYBOMGdX5tu6fzyyNJ0uslPdTWqgAAw1o9M/FDkr5l+wFlP+X4mXYU868/fUy3Pcr+bQCo1lJQR8R9+f7nV0TEWyNiWzuKuezW9frfdVvbsWgAmLb4rQ8ASBxBDQCJI6gBIHHJBTWXBgOAWkkFtT3VFQBAepIKagBAPYIaABJHUANA4pILao4lAkCtpIKaY4kAUC+poAYA1COoASBxBDUAJC65oOZYIgDUSiqozamJAFAnqaAGANQjqAEgcQQ1ACQuuaDmzEQAqJVUUHMoEQDqJRXUAIB6BDUAJI6gBoDEJRfUwbmJAFAjraDmaCIA1Cm10sn2Bkk7JQ1JGoyIvnYWBQAY0VJQ534/Ira2rRIAQENp7foAANRpNahD0k2219he1c6CODMRAGq1uuvjjIjYaPsISTfb/lVE3F7dIQ/wVZJ0zDHHHFIxHEsEgHotbVFHxMb8fouk70s6rUGf1RHRFxF9vb29E1slAMxi4wa17Xm2eyrTks6StLbdhQEAMq3s+lgq6fv51VdKkr4dETe0tSoAwLBxgzoiHpd08iTUwqW4AKABvp4HAIkjqAEgcQQ1ACQuuaAOzngBgBpJBTXHEgGgXlJBDQCoR1ADQOIIagBIXHJBzaFEAKiVVFBzLBEA6iUV1ACAegQ1ACSOoAaAxCUX1JyYCAC1kgpqfuYUAOolFdQAgHoENQAkjqAGgMQlF9TBuYkAUCOpoOZQIgDUSyqoAQD1CGoASBxBDQCJSy6oOTMRAGolFdScmAgA9ZIKagBAvZaD2nbR9i9sX9/OggAAtQ5mi/oiSQ+3qxAAQGMtBbXtoyS9UdJX21sO10wEgNFa3aL+vKSPSyo362B7le1+2/0DAwOHWA5HEwFgtHGD2vZ5krZExJqx+kXE6ojoi4i+3t7eCSsQAGa7VraoXyPpzbY3SLpK0pm2v9nWqgAAw8YN6oi4JCKOiogVks6X9D8R8e62VwYAkJTg96g5MxEAapUOpnNE3Crp1rZUIs5MBIBGktuiBgDUIqgBIHEENQAkLsGg5mgiAFRLKqg5lggA9ZIKagBAPYIaABJHUANA4pILas5MBIBaSQU1ZyYCQL2kghoAUI+gBoDEEdQAkLjkgpqDiQBQK6mgNucmAkCdpIIaAFCPoAaAxBHUAJC45II6+JlTAKiRVFBzZiIA1EsqqAEA9QhqAEgcQQ0AiUsuqDkzEQBqJRXUHEsEgHpJBTUAoN64QW272/bdtu+3/aDtv5uMwgAAmVILffZJOjMidtnukHSH7R9HxJ3tKIhd1ABQa9ygjoiQtCt/2JHf2pKn5owXAKjT0j5q20Xb90naIunmiLirQZ9Vtvtt9w8MDEx0nQAwa7UU1BExFBGvlHSUpNNsv7xBn9UR0RcRfb29vRNdJwDMWgf1rY+I2C7pFklnt6ccAMBorXzro9f2wnx6jqQ/lPSrdhXECS8AUKuVb30sk3Sl7aKyYL86Iq5vb1kAgIpWvvXxgKRTJqEWAEADnJkIAIkjqAEgcckFNZfiAoBaSQU1JyYCQL2kghoAUI+gBoDEEdQAkLj0gppjiQBQI6mg5mAiANRLKqgBAPUIagBIHEENAIlLLqg5lggAtZIKaoujiQAwWlJBDQCoR1ADQOIIagBIXHJBHVw0EQBqJBXUnJkIAPWSCmoAQD2CGgASR1ADQOKSC2oOJQJAraSCmmOJAFAvqaAGANQbN6htH237FtsP2X7Q9kWTURgAIFNqoc+gpI9GxL22eyStsX1zRDzU5toAAGphizoiNkXEvfn0TkkPSzqyXQVxYiIA1DqofdS2V0g6RdJd7SjGnJoIAHVaDmrb8yVdI+kjEbGjwfxVtvtt9w8MDExkjQAwq7UU1LY7lIX0tyLi2kZ9ImJ1RPRFRF9vb+9E1ggAs1or3/qwpMslPRwRn2t/SQCAaq1sUb9G0p9KOtP2ffnt3HYVxLFEAKg17tfzIuIOTdJJgxxKBIB6nJkIAIkjqAEgcQQ1ACQuuaDmmokAUCutoOZoIgDUSSuoAQB1CGoASBxBDQCJSy6oOZQIALWSCmqOJQJAvaSCGgBQj6AGgMQR1ACQuPSCmqOJAFAjqaDmmokAUC+poAYA1COoASBxBDUAJC65oA6OJgJAjaSCmkOJAFAvqaAGANQjqAEgcckFNVfiAoBaSQV1qVjQYJmkBoBqSQV1V6mgvQeGproMAEhKUkHd3VHQvsHyVJcBAEkZN6htX2F7i+217S6mq1TUPraoAaBGK1vUX5d0dpvrkMQWNQA0Mm5QR8Ttkp6fhFqyLWqCGgBqTNg+aturbPfb7h8YGDikZXR3cDARAEabsKCOiNUR0RcRfb29vYe0jO6OovYQ1ABQI6lvfczvKmn3vkEFZ70AwLCkgrqnu0MHhkJ7D7CfGgAqWvl63nck/VzSSbafsf2BdhXT012SJO3ce6BdqwCAaac0XoeIeOdkFCKNBPWOvYM64rDJWisApC2pXR+HdXdIYosaAKolFdQjuz4Gp7gSAEhHUkF92JzKFjVBDQAVSQX1wjyon//N/imuBADSkVRQHz6/S8WCtfmFvVNdCgAkI6mgLhaspT1d2kRQA8CwpIJakpYu6NbmHQQ1AFQkF9TLF8zRxu17proMAEhGckF9whHz9eRzu7VnPz/OBABSgkH9smU9Kof06OadU10KACQhuaB++ZELJEn3PrVtiisBgDQkF9RHLZqr43vn6ZZHDu3iAwAw0yQX1JL0By9bqp+v36otfPsDANIM6neddowGy6HL73hiqksBgCmXZFCvWDJPbz/lKF1+xxNau/GFqS4HAKZUkkEtSZ9848vU29Ol9339Hj3GN0AAzGLJBvXieZ268v2nKSL0tsv+T9+5+ykNlbmWIoDZJ9mglqQTl/bohx86QyuXH6ZLrv2lzv787fr2XU9xYQEAs4rbccXvvr6+6O/vn7DlRYR++MAm/ftt6/Xgr3eoo2j97kuW6HUn9qrv2EVaufwwdRST/swBgDHZXhMRfY3mjXvNxBTY1ptPXq43vWKZ7n1qu25Yu0k3PbRZt12ffdd6TkdRJ/5Wj048Yr5OXNqjE5bO19GL5mj5wjma2zktXiIANDUttqib2fTCHvVv2KY1T27To5t36tHNu7R1176aPovmdmj5wjlatmCODp/XqcXzO7P7eZ06fH6XDp/XqZ7ukuZ3lTS/u6SuUrHtdQPAaNN+i7qZZQvm6E0nz9GbTl4+3LZt936tH9iljdv3ZLdte/Tr7Xv0zLbf6P5ntmvb7v0aHOOgZGexoPmV4M7De15nUV2loro7CuruKKq7o6iujoK6SyP3WXs2v6tUUKlYUEfR6igW1FEsqFSoTFe1FWvbSgXL9mQMHYBpZFoHdSOL5nWqb95iNfxYUra/e8eeQT23e5+e371fz+3er117B7VrX3bbuXdQu/YdGG7buXdQW3ft194DQ9o7OKR9B8r5dFn7B8sTXn9H0SoVRkK8YKtUsIoFq1CQirYKhayt4Ky9mE+XCtm8YlV7cbif8scFFa3hfqXiyHIKrtyy+Va226lgDbdr1GPnz7E13F79HLt+GXa27IKz11T9HKt6uSN9rMo6XFVL1q6srOF6R6YlybXzhvuOPE9VbVm9VdMNlqMGy6pZToN5+SKUL6l5TcPrr51X/by6ekcvhw/7GWfGBfV4bGvB3A4tmNuh43tf3LLK5dC+wbL2DQ5p73CAZ2E+WC7rwFDowFBZg0Oh/fn9gaFyfotRfcraPxQaHDV/qJytZ7AcKkdoqBwaihhpyx8PlUdug+Wy9g2GhkIaqlrG6H7l6sf5tEIqR6ic34eyD7fhx3xDcloaCfvKY9c8ru1T23msPqOX23DZY/U5iLo05jpbr6vuOVXNzZ7fqK7Rr8u2Fs/t1NV//mpNtFkX1BOpULDmdBY1p3P27NeOPKxDlUDPHlfCPUbdV+ZXPx5pG3lc81yFymWNWnbth8ZQeeRDI5QVlM3PHsfw4+x5qm4fft7I/Mg7xRjLGRmD2mU1Xc+ovpV1qmqd1euvXk+j59W1RfP1DK+rsrCqxzXjVtfWvI/q+kRN37Ge3+gDPl5EXWrUZ4x1Nl1Hwz7N6mpee2Wip7s9kUpQ46BUdi1IUrF2+wJAm7T05WPbZ9t+xPY62xe3uygAwIhxg9p2UdKXJJ0jaaWkd9pe2e7CAACZVraoT5O0LiIej4j9kq6S9Jb2lgUAqGglqI+U9HTV42fythq2V9nut90/MMDVWQBgokzYD2RExOqI6IuIvt7eF/m9NwDAsFaCeqOko6seH5W3AQAmQStBfY+kl9o+znanpPMlXdfesgAAFeN+jzoiBm1fKOlGSUVJV0TEg22vDAAgqU2/nmd7QNKTh/j0JZK2TmA5MwXj0hxj0xjj0lyKY3NsRDQ8wNeWoH4xbPc3+6m/2YxxaY6xaYxxaW66jQ2XRQGAxBHUAJC4FIN69VQXkCjGpTnGpjHGpblpNTbJ7aMGANRKcYsaAFCFoAaAxCUT1LP1N69tb7D9S9v32e7P2xbbvtn2Y/n9orzdtv8lH6MHbJ9atZwL8v6P2b5gql7PobJ9he0tttdWtU3YONj+nXyc1+XPnTZXPWgyNpfa3pi/b+6zfW7VvEvy1/mI7TdUtTf8G8vPOr4rb//P/Azk5Nk+2vYtth+y/aDti/L2mfe+yS7nM7U3ZWc8rpd0vKROSfdLWjnVdU3Sa98gacmotn+QdHE+fbGkz+bT50r6sbLLtJ0u6a68fbGkx/P7Rfn0oql+bQc5Dq+TdKqkte0YB0l3532dP/ecqX7NL3JsLpX0sQZ9V+Z/P12Sjsv/ropj/Y1JulrS+fn0v0n64FS/5hbHZZmkU/PpHkmP5q9/xr1vUtmi5jeva71F0pX59JWS3lrV/o3I3Clpoe1lkt4g6eaIeD4itkm6WdLZk130ixERt0t6flTzhIxDPu+wiLgzsr++b1QtK3lNxqaZt0i6KiL2RcQTktYp+/tq+DeWbyGeKel7+fOrxzlpEbEpIu7Np3dKeljZTzDPuPdNKkHd0m9ez1Ah6Sbba2yvytuWRsSmfPpZSUvz6WbjNFPHb6LG4ch8enT7dHdh/l/4Kyr/vdfBj83hkrZHxOCo9mnF9gpJp0i6SzPwfZNKUM9mZ0TEqcoudfaXtl9XPTP/JJ/136FkHOp8WdJLJL1S0iZJ/zy15Uwd2/MlXSPpIxGxo3reTHnfpBLUs/Y3ryNiY36/RdL3lf0XdXP+3y7l91vy7s3GaaaO30SNw8Z8enT7tBURmyNiKCLKkr6i7H0jHfzYPKdsF0BpVPu0YLtDWUh/KyKuzZtn3PsmlaCelb95bXue7Z7KtKSzJK1V9torR54vkPSDfPo6Se/Jj16fLumF/L94N0o6y/ai/L/AZ+Vt092EjEM+b4ft0/N9su+pWta0VAmi3NuUvW+kbGzOt91l+zhJL1V2QKzh31i+xXmLpHfkz68e56Tl/5aXS3o4Ij5XNWvmvW+m6ojt6JuyI7KPKjsy/cmprmeSXvPxyo6+3y/pwcrrVrbf8KeSHpP0E0mL83YruyL8ekm/lNRXtaz3KztwtE7S+6b6tR3CWHxH2X/hDyjbF/iBiRwHSX3Kwmy9pC8qPyt3OtyajM1/5K/9AWUBtKyq/yfz1/mIqr6l0OxvLH8f3p2P2XcldU31a25xXM5QtlvjAUn35bdzZ+L7hlPIASBxqez6AAA0QVADQOIIagBIHEENAIkjqAEgcQQ1ACSOoAaAxP0/rR4yxJ/TjZYAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zzgjNw0VHsxm" + }, + "source": [ + "# Accuracy Finding" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ecNjPxdyHzeW" + }, + "source": [ + "Running test in each row (each traing examples)\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "sbg91GKJjXWy" + }, + "source": [ + "Theeta = [Theeta0,Theeta1,Theeta2,Theeta3,Theeta4,Theeta5,Theeta6,Theeta7,Theeta8,Theeta9]" + ], + "execution_count": 123, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "LkRU6-aoOlwG" + }, + "source": [ + "x_test = test[:,1:]\n", + "y_test = test[:,:1]" + ], + "execution_count": 126, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "tgsprbAWNlzH" + }, + "source": [ + "# Adding one more coloumn to x_test so we can take dot product of it with THEETA\n", + "\n", + "x_n_test = np.arange(9999*785)\n", + "x_n_test = np.reshape(x_n_test,(9999,785))\n", + "\n", + "for i in range(9999):\n", + " x_n_test[i] = np.insert(x_test[i],0,1)\n", + "x_n_test = x_n_test/255" + ], + "execution_count": 127, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "mypRju42gTXf", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "56173b8b-b93e-4cca-ad7a-83770af5aa4f" + }, + "source": [ + "accurates =[]\n", + "\n", + "for i in range(10):\n", + " correct = 0\n", + " y = y_test\n", + " for j in range(9999):\n", + "\n", + " if y_test[j]==i:\n", + " y[j]=1\n", + " else:\n", + " y[j]=0\n", + "\n", + " # finding the hypothesis by taking the Theeta\n", + " # And cheacking that if the model can determine its correcct value or not\n", + " \n", + " g_temp = np.dot(Theeta[i],x_n_test[j])\n", + " hypothesis = 1/(1+np.exp(-g_temp))\n", + "\n", + " if hypothesis>=0.5:\n", + " hypothesis = 1\n", + " else:\n", + " hypothesis = 0\n", + " \n", + " if hypothesis == y_test[j] :\n", + " correct+=1\n", + "\n", + " accurates.append(correct)\n", + "\n", + " print(correct/9999*100,' is accuracy for digit',i)" + ], + "execution_count": 139, + "outputs": [ + { + "output_type": "stream", + "text": [ + "10.071007100710071 is accuracy for digit 0\n", + "10.05100510051005 is accuracy for digit 1\n", + "90.67906790679068 is accuracy for digit 2\n", + "90.3990399039904 is accuracy for digit 3\n", + "90.46904690469046 is accuracy for digit 4\n", + "92.04920492049204 is accuracy for digit 5\n", + "90.2890289028903 is accuracy for digit 6\n", + "89.97899789978999 is accuracy for digit 7\n", + "91.06910691069106 is accuracy for digit 8\n", + "90.22902290229023 is accuracy for digit 9\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Ojo6UuaDls0h", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "220e8d96-ef59-4f92-eebb-e49557532d19" + }, + "source": [ + "# Just finding the percentage of accuracy of the model\n", + "t = 0\n", + "for i in range(2,10):\n", + " t+=accurates[i]\n", + "\n", + "\n", + "print(\"\\n\\n\\n\\n\\n\\n\\n\\nTHE ACCURACY OF MY THIS LOGISTIC REGRESSION MODEL IS :\")\n", + "print(t/9999*100/8)" + ], + "execution_count": 145, + "outputs": [ + { + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "THE ACCURACY OF MY THIS LOGISTIC REGRESSION MODEL IS :\n", + "90.64531453145315\n" + ], + "name": "stdout" + } + ] + } + ] +} \ No newline at end of file From c0c9650060cf81fba6fa99bbd9773ac8d2020ba0 Mon Sep 17 00:00:00 2001 From: Vivek Patidar <77988917+vivekpatidar1413@users.noreply.github.com> Date: Sat, 10 Apr 2021 16:03:37 +0530 Subject: [PATCH 4/4] Created using Colaboratory --- FINAL_LogisticRegression.ipynb | 80 +++++++++++++--------------------- 1 file changed, 30 insertions(+), 50 deletions(-) diff --git a/FINAL_LogisticRegression.ipynb b/FINAL_LogisticRegression.ipynb index 1a7d2c0..f6c96a7 100644 --- a/FINAL_LogisticRegression.ipynb +++ b/FINAL_LogisticRegression.ipynb @@ -7,7 +7,7 @@ "provenance": [], "collapsed_sections": [], "toc_visible": true, - "authorship_tag": "ABX9TyO6JxHl6zAXYvtXj6wgQs0t", + "authorship_tag": "ABX9TyOG1GceGFPB5mKml3kGBWud", "include_colab_link": true }, "kernelspec": { @@ -48,7 +48,7 @@ "import pandas as pd\n", "from matplotlib import pyplot as plt" ], - "execution_count": 109, + "execution_count": null, "outputs": [] }, { @@ -60,7 +60,7 @@ "train_df = pd.read_csv(\"/content/sample_data/mnist_train_small.csv\")\n", "test_df = pd.read_csv(\"/content/sample_data/mnist_test.csv\")" ], - "execution_count": 110, + "execution_count": null, "outputs": [] }, { @@ -81,7 +81,7 @@ "train = train_df.to_numpy()\n", "test = test_df.to_numpy()" ], - "execution_count": 111, + "execution_count": null, "outputs": [] }, { @@ -97,7 +97,7 @@ "print(train.shape)\n", "print(train)" ], - "execution_count": 112, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -133,7 +133,7 @@ "x_train = train[:,1:]\n", "y_train = train[:,:1]" ], - "execution_count": 113, + "execution_count": null, "outputs": [] }, { @@ -151,7 +151,7 @@ " x_n_train[i] = np.insert(x_train[i],0,1)\n", "x_n_train = x_n_train/255" ], - "execution_count": 115, + "execution_count": null, "outputs": [] }, { @@ -167,7 +167,7 @@ "print(y_train.shape)\n", "print(x_n_train.shape)" ], - "execution_count": 116, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -202,7 +202,7 @@ "''' ONE VS ALL'''\n", "# classifier" ], - "execution_count": 117, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -240,8 +240,9 @@ "id": "yCcBbllQm1Zb" }, "source": [ - "def THE_MAIN_FUNCTION(n,X,Y):\n", - "\n", + "def THE_MAIN_FUNCTION(n,x_,y_):\n", + " Y = y_\n", + " X = x_\n", " # Let the iterations be 50000\n", " itrations = 50000\n", " # let the learning rate be 0.16\n", @@ -252,6 +253,7 @@ " '''Converting the Y_TRAIN in BINARY FORM'''\n", " '''Y be 1 if the number is same as the digit to be trained(n)'''\n", " '''Y be 0 if the number is not equal as the digit to be trained(n)'''\n", + "\n", " for i in range(19999):\n", " if Y[i]==n:\n", " Y[i]=1\n", @@ -303,7 +305,7 @@ "\n", " return Theeta,Cost_Function" ], - "execution_count": 118, + "execution_count": null, "outputs": [] }, { @@ -318,7 +320,7 @@ "source": [ "y_train" ], - "execution_count": 27, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -340,28 +342,6 @@ } ] }, - { - "cell_type": "code", - "metadata": { - "id": "pBB__Gt7BbpS" - }, - "source": [ - "" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "pGwZsoqzBbl-" - }, - "source": [ - "" - ], - "execution_count": null, - "outputs": [] - }, { "cell_type": "code", "metadata": { @@ -375,7 +355,7 @@ "Theeta0 , Cost_Function0 = THE_MAIN_FUNCTION (0,x_n_train,y_train)\n", "Theeta1 , Cost_Function1 = THE_MAIN_FUNCTION (1,x_n_train,y_train)" ], - "execution_count": 11, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -415,7 +395,7 @@ "source": [ "Theeta2 , Cost_Function2 = THE_MAIN_FUNCTION (2,x_n_train,y_train)" ], - "execution_count": 40, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -448,7 +428,7 @@ "source": [ "Theeta3 , Cost_Function3 = THE_MAIN_FUNCTION (3,x_n_train,y_train)" ], - "execution_count": 52, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -480,7 +460,7 @@ "source": [ "Theeta4 , Cost_Function4 = THE_MAIN_FUNCTION (4,x_n_train,y_train)" ], - "execution_count": 64, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -513,7 +493,7 @@ "source": [ "Theeta5 , Cost_Function5 = THE_MAIN_FUNCTION (5,x_n_train,y_train)" ], - "execution_count": 75, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -546,7 +526,7 @@ "source": [ "Theeta6 , Cost_Function6 = THE_MAIN_FUNCTION (6,x_n_train,y_train)" ], - "execution_count": 86, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -578,7 +558,7 @@ "source": [ "Theeta7 , Cost_Function7 = THE_MAIN_FUNCTION (7,x_n_train,y_train)" ], - "execution_count": 97, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -609,7 +589,7 @@ "source": [ "Theeta8 , Cost_Function8 = THE_MAIN_FUNCTION (8,x_n_train,y_train)" ], - "execution_count": 108, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -641,7 +621,7 @@ "source": [ "Theeta9 , Cost_Function9 = THE_MAIN_FUNCTION (9,x_n_train,y_train)" ], - "execution_count": 119, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -728,7 +708,7 @@ "plt.title(\"9's dataset\")\n", "plt.show()" ], - "execution_count": 120, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -888,7 +868,7 @@ "source": [ "Theeta = [Theeta0,Theeta1,Theeta2,Theeta3,Theeta4,Theeta5,Theeta6,Theeta7,Theeta8,Theeta9]" ], - "execution_count": 123, + "execution_count": null, "outputs": [] }, { @@ -900,7 +880,7 @@ "x_test = test[:,1:]\n", "y_test = test[:,:1]" ], - "execution_count": 126, + "execution_count": null, "outputs": [] }, { @@ -918,7 +898,7 @@ " x_n_test[i] = np.insert(x_test[i],0,1)\n", "x_n_test = x_n_test/255" ], - "execution_count": 127, + "execution_count": null, "outputs": [] }, { @@ -961,7 +941,7 @@ "\n", " print(correct/9999*100,' is accuracy for digit',i)" ], - "execution_count": 139, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1000,7 +980,7 @@ "print(\"\\n\\n\\n\\n\\n\\n\\n\\nTHE ACCURACY OF MY THIS LOGISTIC REGRESSION MODEL IS :\")\n", "print(t/9999*100/8)" ], - "execution_count": 145, + "execution_count": null, "outputs": [ { "output_type": "stream",