logistic_regression_from_scratch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First guess at a, b  5.0 3.5\n",
      "First loss function is  7.890933746255283\n",
      "Best a,b is  1.2036993070662023 3.310473877247611\n",
      "Best loss function is  2.690376323682816\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import autograd.numpy as np\n",
    "from autograd import grad\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "# logistic regression is a classification algorithm, which does not \n",
    "# give out continuous values as the linear model does instead logistic\n",
    "# regression will compute the probability of a observation and based \n",
    "# on that value, the observation will be mapped to a class as per a \n",
    "# given threshold.\n",
    "# The function logistic() below is the sigmoid function, which will give \n",
    "# output values ranging from 0 to 1(probability)\n",
    "# the sigmoid function s(z) = 1/ 1+(e^-z), where \"z\" is mx+b which is part \n",
    "# of model's equation and \"e\" is Euler's number i.e 2.718281 \n",
    "# Types of logistic regression : 1.Binary (Pass/Fail)\n",
    "#                                2.Multi (Cats, Dogs, Sheep)\n",
    "#                                3.Ordinal (Low, Medium, High)\n",
    "# sigmoid function which we are using is a binary type, the plot od sigmoid\n",
    "# curve shows how the output isassigned to 0 for -ve number and 1 for \n",
    "# positive number.\n",
    "\n",
    "\n",
    "def logistic(x,a,b):\n",
    "    return 1/(1.0+np.exp(-a*x+b))\n",
    "\n",
    "# loss function takes in 4 arguments, of x, y_obs which are arrays of 20 \n",
    "# elements each and a and b are defined below as random number to initiate \n",
    "# the process.\n",
    "# the loss is computed by actual y_obs and y_predicted values, \n",
    "# the formula to compute loss is same as that for linear regression.\n",
    "# which is sum of squared distances between predicted to actual value.\n",
    "def loss(x,y_obs,a,b):\n",
    "    y_model = logistic(x,a,b)\n",
    "    return np.sum( (y_model-y_obs)**2 )\n",
    "\n",
    "# x and y_obs are created, using numpy array and these will be used later for \n",
    "# plotting the observation in scatter plot\n",
    "# y_obs are all divided among the value 1 and 0 for each set of 10 \n",
    "# observations. \n",
    "# This is purposely done here since we are not specifying\n",
    "# any classes or threshold to which the observation will be assigned or \n",
    "# divided among. \n",
    "x = np.array( [0.50,0.75,1.00,1.25,1.50,1.75,1.75,2.00,2.25,2.50,2.75,3.00,3.25,\n",
    "               3.50,4.00,4.25,4.50,4.75,5.00,5.50] )\n",
    "y_obs = np.array( [0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1] )\n",
    "\n",
    "# for now random values for a and b are chosen.\n",
    "a,b = 5.0,3.5\n",
    "y_model = logistic(x,a,b) # array of probabilities from 1 to 0 for \n",
    "# all 20 observation\n",
    "\n",
    "# printing out the values of the four arguments before starting \n",
    "# the iteration to compare them with the end result after iteration. \n",
    "# loss should be reduced at the end of iteration, with the learning \n",
    "# and changing values of a and b per iteration.\n",
    "print('First guess at a, b ',a,b)\n",
    "print('First loss function is ',loss(x,y_obs,a,b))\n",
    "\n",
    "# grad function takes in the function which produce scalar value. \n",
    "# In this case loss produces scalar value as output.\n",
    "# d_by_da gives derivative of loss with respect to slope i.e \"a\" \n",
    "# which is the 3rd argument in loss function(2nd position)\n",
    "# d_by_db gives derivative of y-intercept with respect to slope \n",
    "# i.e \"b\" which is the \n",
    "# 4th argument in loss function(3nd position)\n",
    "d_by_da = grad(loss,2) \n",
    "d_by_db = grad(loss,3) \n",
    "# d(loss)/d(a) loss is differentiated with respect to \"a\"\n",
    "# d(loss)/d(b) loss is differentiated with respect to \"b\"\n",
    "\n",
    "\n",
    "# learning rate is the steps by which \"a\" and \"b\" are being updated \n",
    "# till the loss is minimum.\n",
    "learning_rate = 0.001\n",
    "maximum_number_of_iterations = 50000\n",
    "ssr = []\n",
    "\n",
    "# loop will run for 50,000 times, by the time which \"a\" and \"b\" values \n",
    "# will be updated to the point where loss will be minimum.\n",
    "# ssr/loss array will have 50000 values at the end of the iteration\n",
    "for iter in range(maximum_number_of_iterations): \n",
    "    a -= learning_rate*d_by_da(x,y_obs,a,b)\n",
    "    b -= learning_rate*d_by_db(x,y_obs,a,b)              \n",
    "    y_model = logistic(x,a,b)\n",
    "    ssr.append(loss(x,y_obs,a,b))\n",
    "\n",
    "# final a,b and loss value are displayed\n",
    "print('Best a,b is ',a,b)\n",
    "print('Best loss function is ',loss(x,y_obs,a,b))\n",
    "\n",
    "# The sigmoid plot (curve) for x and y_model is accurately starting \n",
    "# from 0 and ending to 1 and is capturing the obseravtion occurdingly. \n",
    "# the loss/ssr plot shows that initial loss was high but by 1000th \n",
    "# iteration the loss started to gradually reduce. Which shows that our\n",
    "# model is fits well\n",
    "plt.subplot(1,2,1)\n",
    "plt.scatter(x,y_obs)\n",
    "plt.plot(x,y_model)\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "plt.plot(ssr)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fb68d589828>]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# semilogy is just a thin wrapper around plot which additionally changes \n",
    "# the y-axis to log scaling  and a linear scale for the x-axis. \n",
    "#It plots the columns of Y versus their index\n",
    "plt.semilogy(ssr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.26894142, 0.5621765 , 0.81757448, 0.93991335, 0.98201379,\n",
       "       0.99477987, 0.99477987, 0.99849882, 0.99956944, 0.99987661,\n",
       "       0.99996464, 0.99998987, 0.9999971 , 0.99999917, 0.99999993,\n",
       "       0.99999998, 0.99999999, 1.        , 1.        , 1.        ])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array( [0.50,0.75,1.00,1.25,1.50,1.75,1.75,2.00,2.25,2.50,\n",
    "               2.75,3.00,3.25,3.50,4.00,4.25,4.50,4.75,5.00,5.50] )\n",
    "y_obs = np.array( [0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1] )\n",
    "\n",
    "# for now random values for a and b are chosen.\n",
    "a,b = 5.0,3.5\n",
    "def logistic(x,a,b):\n",
    "    return 1/(1.0+np.exp(-a*x+b))\n",
    "y_model = logistic(x,a,b)\n",
    "y_model # y_model is an array which has the probability values \n",
    "# which is ranging from 0 and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss(x,y_obs,a,b):\n",
    "    y_model = logistic(x,a,b)\n",
    "    return np.sum( (y_model-y_obs)**2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.709244592836294"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss(x,y_obs,a,b) # scalar value output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "reference link:\n",
    "\n",
    "https://ml-cheatsheet.readthedocs.io/en/latest/logistic_regression.html\n",
    "\n",
    "https://www.youtube.com/watch?v=yIYKR4sgzI8&t=57s"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}