Linear_Regression_from_Scratch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is Linear Regression ?\n",
    "\n",
    "        Linear regression assumes a linear or straight line relationship between the input variables (X) and\n",
    "        single output variable (y).\n",
    "\n",
    "        The output 'Y' or the prediction h(x) can be estimated from a linear combination of the input variables (X). \n",
    "        When there is a single input variable X = [X1] , then this method is called simple linear regression.\n",
    "        \n",
    "        in such case h(x)= theta0 + theta1*X1\n",
    "        where theta0, theta1 are co efficients ; comapring with Y = c + mx\n",
    "        theta0 can be considered as 'c' the intercept term and theta1 as 'm' the slope\n",
    "        \n",
    "        We then require a cost function such that\n",
    "        it calculates the mean squared error between the actual value of Y and our estimated value h(x)\n",
    "        \n",
    "        Then we need to minimize this error by changing the values of theta0 and theta1 \n",
    "        this is done by a method called Gradient descent\n",
    "        after the error is minimized we use those values of theta0 and theta1 for which the error is minimum\n",
    "        or when our estimated value is almost same as the actual value\n",
    "        \n",
    "        These values of Theta0 and Theta1 are the used to predict Y for values of X (X = [X1] single attribute) in testset\n",
    "        predicted Y = theta0(minimized) + theta1 * Xi ; \n",
    "        where xi is the ith example in the test set and Yi is the actual value of Y for Xi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Requirements:\n",
    "\n",
    "            let prediction(theta,Xi) be a function that estimates Yi for given Xi and Optimum theta.\n",
    "            Prediction(theta,Xi): theta is 1d vector [theta0 , theta1]; theta is the optimized value of theta such \n",
    "            that the difference between predicted value and actual value (cost/mean squared error) is minimum.\n",
    "            \n",
    "                Xi is an example or an instance of X (an entire row with only 1 attribute X1)\n",
    "                The predicted value for Xi is given by:\n",
    "                Prediction(theta,Xi) = theta0 + Theta1* Xi\n",
    "                                     = theta0*X0 + Theta1 * X1 (X0 is always =1)\n",
    "                        \n",
    "                        \n",
    "            for easy of calculation using vector multiplication we add a vector X0 to our X\n",
    "            X0 is a M dimensional vector of all 1's where M is the number of rows or no of examples in X\n",
    "            so X = [X0, X1] \n",
    "            where, X0 is a column of all 1 X1 is the coloumn containing the value of attribute X1 for each row/example in X\n",
    "            \n",
    "            then prediction(theta,Xi) = Theta * Xi' ; theta * Xi(Transpose) \n",
    "            now we need to get the optimum value of theta\n",
    "            for this we require i)  cost function: to calculate the Mean sq error\n",
    "                                ii) gradient descent to minimize the cost function with respect to theta\n",
    "                                \n",
    "            Before diving in the cost function\n",
    "            we require a method to transpose a 1d vector and also to add a column X0 to X\n",
    "            such that all X0 = 1\n",
    "            example if X = [[2],[1],[6]]\n",
    "            then after adding X0 terms : X = [[1,2],[1,1],[1,6]]\n",
    "            \n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function to Transpose an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Transpose(x): # x is np array of dimension 1 X n ; 1 row , n columns (n being the number of attributes)\n",
    "    x = np.array(x)\n",
    "    x = x.transpose()\n",
    "    return x  # returns a vector of size n X 1 ;n rows , 1 column "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How Transpose works:\n",
    "\n",
    "        Note : In python each sublist is a row and no of element in each sublist = num of cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]\n",
      " [2]\n",
      " [3]]\n",
      "\n",
      "[[1 3]\n",
      " [2 6]]\n"
     ]
    }
   ],
   "source": [
    "y = [[1,2,3]]\n",
    "#then we should get yT = [[1],[2],[3]]\n",
    "x = [[1,2],[3,6]] \n",
    "# then xT = [[1,3],[2,6]]\n",
    "yT = Transpose(y)\n",
    "print(yT)\n",
    "print(\"\")\n",
    "xT = Transpose(x)\n",
    "print(xT)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function to add X0 column in X :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addX0(X):      ## X = [X1,X2] we need x1 and x2 to be seperate rows X = [[x1],[x2]]\n",
    "    X = np.array(X,dtype=float)\n",
    "    l = len(X)\n",
    "    X0 = np.ones((l,1),dtype=float)  # creating a column of 1\n",
    "    X = np.column_stack((X0,X)) \n",
    "    return X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How inserting X0 works: \n",
    "\n",
    "        consider the following example given in cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2.],\n",
       "       [1., 3.]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [2,3] #its still a list \n",
    "x = np.array(x)\n",
    "l = len(x)\n",
    "X0 = np.ones((l,1),dtype=float)\n",
    "X = np.column_stack((X0,x))\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 1 : The Cost Function Cost(theta):\n",
    "\n",
    "        Cost(X,Y,theta) : simply calcultes the sum of all mean squared errors between h(Xi) and Yi\n",
    "        so : Cost(theta): = (1/2M) * sum((h(xi)-yi)^2) where i = 1 to M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def costFunc(X,Y,theta):\n",
    "    m = len(Y)\n",
    "    \n",
    "    Y = np.array([Y])\n",
    "    Y = Transpose(Y)                              # Y = Y' coloumn vector\n",
    "    \n",
    "    theta= np.array([theta])\n",
    "    theta= Transpose(theta)                       # theta = theta' coloumn vector\n",
    "   \n",
    "    X = addX0(X)                         # adding X0 column to X\n",
    "    \n",
    "    estimated_val = X @ theta               #  @ : matrix multiplication , * : scalar multiplication\n",
    "        \n",
    "    error = np.subtract(estimated_val,Y)    # matrix subtraction\n",
    "    sq_error = error **2                # element wise square\n",
    "    \n",
    "    cost = 1/(2*m) * sum(sq_error)\n",
    "    return cost[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Verify if Cost function works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.25"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = [[1,2,1],[1,8,2]]\n",
    "Y=[12,28]\n",
    "theta = [1,3,2,5]\n",
    "# m(no of rows = 2)\n",
    "# x becomes = X[[1,1,2,1],[1,2,8,2]] Y= [[2],[8]] theta = [[1],[3],[2],[5]]\n",
    "#hpy = [[(1*1 + 1*3 + 2*2 +1*5)],[(1*1+1*3+8*2+2*5)] ] = [[13],[26]]\n",
    "#error = [[13-12],[26-28]]=[[1],[-2]]\n",
    "#sq_error = [[1],[4]]\n",
    "#cost = (1/4) * sum(1+4)=5/4=1.25\n",
    "cost = costFunc(X,Y,theta)\n",
    "cost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 1 : Minimize the cost function with respect to theta :\n",
    "\n",
    "#             what is gradient descent ?\n",
    "\n",
    "        Gradient descent is an optimization algorithm used to find the values of parameters (coefficients) \n",
    "        of  cost function (f) that minimizes a cost function\n",
    "    \n",
    "        psuedocode:\n",
    "            \n",
    "        repeat untill no change in Theta\n",
    "        {\n",
    "            theta(j) = theta(j) - alpha *  d/d(thetaj) (cost(theta))\n",
    "        } for 0<=j<=n \n",
    "        (as we add the X0 intercept term so if there is only 1 feature n=1 we will have theta0 & theta 1 hence 0<=j<=n )\n",
    "        \n",
    "        what is alpha ?\n",
    "        The learning rate.\n",
    "        it controls by how much the coefficients (theta) changes with each update\n",
    "        alpha large : the value of theta decreases rapidly with each update\n",
    "        alpha small the value of theta decreases slowly with each update\n",
    "        \n",
    "        vectorized implementation:\n",
    "            \n",
    "        d/d(theta(j) cost(theta) = d/d(theta(j) {(1/2M) * sum((h(xi)-yi)^2) } where i = 1 to M\n",
    "        after differentiating we get :\n",
    "                                       \n",
    "        d/d(theta(j) cost(theta) = (1/M) * sum{(h(xi)-yi)X(i,j)} where i = 1 to M (row number )and j = column number  \n",
    "            \n",
    "        so:\n",
    "        theta(0)= theta(0) - alpha* {(1/M) * sum{ (h(xi)-yi) * X(i,0) }} for i = 1 to M (row number )\n",
    "        theta(1)= theta(1) - alpha* {(1/M) * sum{ (h(xi)-yi) * X(i,1) }} for i = 1 to M (row number )\n",
    "        .\n",
    "        .\n",
    "            \n",
    "        now let delta = (1/M) * sum{ (h(xi)-yi) * X(i,j) } ,  h(xi)-yi): error for each estimated vs actual value\n",
    "                delta = (1/M) * sum{ error * X(i,j) } ;   0 <= j <= n ; n = number of features , (from 0 as X0 is added)\n",
    "                X(i,j) : depends on theta(for theta 1 : X(i,1)) while i denotes all rows \n",
    "                its basically a 1-dimensional vector\n",
    "                \n",
    "         so Theta = Theta - alpha*delta\n",
    "         \n",
    "         lastly, the values of theta vector for which the cost is minimum is our optimized theta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementing Gradient descent:\n",
    "\n",
    "            vectorized implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def GradientDescent(x,y,theta,alpha,num_iterations):\n",
    "    \n",
    "    no_of_examples = len(y)\n",
    "    cost_history = np.zeros(num_iterations,dtype=float)\n",
    "    #cost_history is an array with elements=num_iteration, to store change in cost(mean sq error)to chekc for convergence\n",
    "    \n",
    "    Y = np.array([y])\n",
    "    Y = Transpose(Y)                              # Y = y' coloumn vector\n",
    "    Theta= np.array(theta)\n",
    "    Theta= Transpose(Theta)                       # Theta = theta' coloumn vector\n",
    "    X = addX0(x)                                  # adding X0 column to x \n",
    "    \n",
    "    for i in range(num_iterations):\n",
    "        cost_history[i] = costFunc(x,y,Theta)\n",
    "        \n",
    "        estimated_val = X @ Theta               #  @ : matrix multiplication , * : scalar multiplication\n",
    "        error = np.subtract(estimated_val,Y)    # matrix subtraction\n",
    "        delta = Transpose(X) @ error       \n",
    "        delta = delta/no_of_examples\n",
    "        \n",
    "        Theta = Theta - (alpha * delta)\n",
    "        \n",
    "    return Theta,cost_history"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Dataset:\n",
    "    \n",
    "    Dataset contains two Columns X & Y \n",
    "    number of examples = 97\n",
    "    X is treated as the feature\n",
    "    Y is treated as the variable dependent on X "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>X</th>\n",
       "      <th>Y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6.1101</td>\n",
       "      <td>17.5920</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5.5277</td>\n",
       "      <td>9.1302</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8.5186</td>\n",
       "      <td>13.6620</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>7.0032</td>\n",
       "      <td>11.8540</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.8598</td>\n",
       "      <td>6.8233</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        X        Y\n",
       "0  6.1101  17.5920\n",
       "1  5.5277   9.1302\n",
       "2  8.5186  13.6620\n",
       "3  7.0032  11.8540\n",
       "4  5.8598   6.8233"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.read_csv('data.txt',header=None)\n",
    "data.columns=['X','Y']\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>X</th>\n",
       "      <th>Y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>97.000000</td>\n",
       "      <td>97.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>8.159800</td>\n",
       "      <td>5.839135</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>3.869884</td>\n",
       "      <td>5.510262</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>5.026900</td>\n",
       "      <td>-2.680700</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>5.707700</td>\n",
       "      <td>1.986900</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>6.589400</td>\n",
       "      <td>4.562300</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>8.578100</td>\n",
       "      <td>7.046700</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>22.203000</td>\n",
       "      <td>24.147000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               X          Y\n",
       "count  97.000000  97.000000\n",
       "mean    8.159800   5.839135\n",
       "std     3.869884   5.510262\n",
       "min     5.026900  -2.680700\n",
       "25%     5.707700   1.986900\n",
       "50%     6.589400   4.562300\n",
       "75%     8.578100   7.046700\n",
       "max    22.203000  24.147000"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = data['X']\n",
    "Y = data['Y']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.array(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y = np.array(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "67\n",
      "67\n",
      "30\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "X_train,X_test,Y_train,Y_test = train_test_split(X,Y,test_size = 0.3,random_state = 42)\n",
    "print(len(X_train))\n",
    "print(len(Y_train))\n",
    "print(len(X_test))\n",
    "print(len(Y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Theta value we got after 20 iteration\n",
      "\n",
      "[[0.00125051]\n",
      " [0.8111048 ]]\n",
      "-------------------------------------\n",
      "change in cost with iteration\n",
      "\n",
      "[0.61190176 0.15211041 0.02624355 0.00086587 0.00227297 0.00856305\n",
      " 0.01408007 0.01792688 0.02038992 0.0219088  0.02283147 0.02339146\n",
      " 0.02373513 0.02395116 0.02409234 0.02418977 0.02426168 0.02431873\n",
      " 0.02436712 0.02441047]\n"
     ]
    }
   ],
   "source": [
    "alpha = 0.005\n",
    "n = np.size(X[1])+1                          # no of features in X + 1 for X0 term which will be added\n",
    "initial_Theta = np.zeros((1,n),dtype=float)  # initialize theta vector with all 0's\n",
    "iterations = 20\n",
    "theta,cost_history=GradientDescent(x=X_train,y=Y_train,theta=initial_Theta,alpha=alpha,num_iterations=iterations)\n",
    "print(\"Theta value we got after 20 iteration\\n\")\n",
    "print(theta)\n",
    "print(\"-------------------------------------\")\n",
    "print(\"change in cost with iteration\\n\")\n",
    "print(cost_history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Find the optimal num of iterations required for Convergence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_dpi = 100 # dots per inch .. (resolution)\n",
    "plt.figure(figsize=(1000/my_dpi, 400/my_dpi), dpi = my_dpi) # to enlarge the plot (can be omitted)\n",
    "\n",
    "plt.plot(np.arange(0,iterations,step=1),cost_history,label=\"mean sq error\")\n",
    "plt.xticks(np.arange(0,iterations,step=1))\n",
    "plt.xlabel('Iterations')\n",
    "plt.ylabel('Mean squared error')\n",
    "plt.legend()\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Trying to vizualize the convergence point better:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_dpi = 100 # dots per inch .. (resolution)\n",
    "plt.figure(figsize=(1000/my_dpi, 400/my_dpi), dpi = my_dpi) # to enlarge the plot (can be omitted)\n",
    "\n",
    "plt.plot(np.arange(1,10,step=1),cost_history[1:10],linewidth=1,label=\"mean sq error\")\n",
    "plt.xticks(np.arange(1,10,step=1))\n",
    "plt.xlabel('Iterations')\n",
    "plt.ylabel('Mean squared error')\n",
    "plt.ylim(0,0.1)\n",
    "plt.yticks(np.arange(0,0.1,step=0.01))\n",
    "plt.legend()\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inference :\n",
    "\n",
    "    we see on the 4th iteration(as interation starts from 0) the error is minimum, and increases again \n",
    "    when iterations are increased.\n",
    "    Hence we select number of iterations = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal value of theta\n",
      "\n",
      "[[0.05535396]\n",
      " [0.71312766]]\n",
      "-------------------------------------\n",
      "final Mean squared error: 0.000865875 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "alpha = 0.005\n",
    "n = np.size(X[1])+1                          # no of features in X + 1 for X0 term which will be added\n",
    "initial_Theta = np.zeros((1,n),dtype=float)  # initialize theta vector with all 0's\n",
    "iterations = 4                             # best value of iteration from graph\n",
    "optimized_theta,cost_history=GradientDescent(x=X_train,y=Y_train,theta=initial_Theta,alpha=alpha,num_iterations=iterations)\n",
    "print(\"Optimal value of theta\\n\")\n",
    "print(optimized_theta)\n",
    "print(\"-------------------------------------\")\n",
    "print(\"final Mean squared error: %.9f \\n\" %cost_history[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Predicting Y from X in test Set(X_test):\n",
    "\n",
    "        first checking with a single test case\n",
    "        Here we will be predicting for the 10th example(row) in the test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.    , 21.279 ],\n",
       "       [ 1.    ,  5.4069],\n",
       "       [ 1.    ,  5.3054],\n",
       "       [ 1.    ,  6.4296],\n",
       "       [ 1.    ,  5.1884]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "finalX_test = addX0(X_test) # the bias/intercept term from theta0 , X0 needs to be added\n",
    "finalX_test[0:5]        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.929000000000002"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "actual_value = Y_test[0]\n",
    "actual_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Making Predictions of Y given the value of X:\n",
    "\n",
    "        pred = X * Theta; where X is (mXn) Matrix and theta is (nX1) column vector\n",
    "        The result will be a mX1 vector , where m is no of rows in X\n",
    "        Here :\n",
    "        X = (1X2) matrix ; a single row from X_test  \n",
    "        optimized_theta = (2X1) column vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.229997517006257"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted_value = finalX_test[0] @ optimized_theta\n",
    "predicted_value[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prediction for entire Test set and ploting it as the best fit line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "rows = len(finalX_test)\n",
    "pred = np.zeros((rows),dtype=float)\n",
    "pred               \n",
    "for i in range(rows):\n",
    "    pred[i] = finalX_test[i] @ optimized_theta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'Linear Regression without feature scaling')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_dpi = 100 # dots per inch .. (resolution)\n",
    "plt.figure(figsize=(1000/my_dpi, 400/my_dpi), dpi = my_dpi) # to enlarge the plot (can be omitted)\n",
    "\n",
    "Testsetplt=plt.scatter(X_test,Y_test,color='r',s=5, label = 'Test set(xi,yi)')\n",
    "bestfitline=plt.plot(X_test,pred,linewidth = 0.5,label = 'prediction(yi)=theta0 + theta1*xi')\n",
    "plt.xlabel('X (Features)')\n",
    "plt.ylabel('Y (Actual Values)')\n",
    "plt.legend()\n",
    "plt.title(\"Linear Regression without feature scaling\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feature Scaling:\n",
    "\n",
    "    Linear Regression uses Gradient descent for minimizing the cost function\n",
    "\n",
    "    Theta = Theta - alpha * [ (1/M) * sum{ (h(xi)-yi) * X(i,j) } ]\n",
    "\n",
    "    The presence of feature value X in the formula will affect the step size of the gradient descent.\n",
    "    The difference in ranges of features will cause different step sizes for each feature.\n",
    "    To ensure that the gradient descent moves smoothly towards the minima and that the steps for gradient descent\n",
    "    are updated at the same rate for all the features, we scale the data before feeding it to the model.\n",
    "\n",
    "    we are going to use Feature Standardization\n",
    "\n",
    "    Standardization is scaling technique where the values are centered around the mean with a unit standard deviation.\n",
    "    This means that the mean of the attribute becomes zero and the resultant distribution has a unit standard deviation.\n",
    "        \n",
    "        xk' = (xk - mean(x))/std(x) ; where xk is a value of feature x, xk' is the scaled value for xk\n",
    "                                      mean(x): mean of all values under feature x\n",
    "                                      std(x): standard deviation of all values under feature x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_Mean(x):\n",
    "    return sum(x)/len(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# std deviation formula:\n",
    "\n",
    "    Std div = square root of varience\n",
    "    varience = calculate the Mean of all numbers\n",
    "               Then for each number: subtract the Mean and square the Difference\n",
    "               Then add all the squared differences and divide by total numbers -1(mean of the Squared difference)\n",
    "               Note :the std_div formula i saw had N-1 hence i am implementing according to formula"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_StdDiv(x):\n",
    "    mean = calculate_Mean(x)\n",
    "    sum_sq_diff = 0\n",
    "    for xi in x:\n",
    "        diff = xi - mean\n",
    "        sum_sq_diff += pow(diff,2)\n",
    "    \n",
    "    varience = sum_sq_diff/(len(x)-1)\n",
    "    std_div = math.sqrt(varience)\n",
    "    \n",
    "    return std_div"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.159800000000002"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean = calculate_Mean(X)\n",
    "mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.8698835278823314"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = calculate_StdDiv(X)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function For Scaling The Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Standard_Scaler(X):\n",
    "    \n",
    "    X_scaled = np.zeros(X.shape,dtype=float)\n",
    "    no_of_rows = len(X)\n",
    "    mean = calculate_Mean(X)\n",
    "    std_div = calculate_StdDiv(X)\n",
    "    \n",
    "    for i in range(no_of_rows):\n",
    "        X_scaled[i] = ( X[i] - mean )/std_div\n",
    "        \n",
    "    return X_scaled   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6.1101, 5.5277, 8.5186, 7.0032, 5.8598])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.52965418, -0.68014967,  0.09271597, -0.29887204, -0.59433313,\n",
       "        0.05765031, -0.17659446,  0.10809111, -0.4324678 , -0.80240141,\n",
       "       -0.63286142,  1.55151956, -0.62684057,  0.06423966, -0.65094982,\n",
       "       -0.71847124, -0.46368321, -0.78289178, -0.44709356, -0.28140382,\n",
       "       -0.50924013,  3.12934483, -0.68986572, -0.47383855, -0.67053698,\n",
       "        2.78695726,  1.20628953,  0.72281245,  1.29621472,  3.62884306,\n",
       "       -0.75128876, -0.40580033,  0.28124877, -0.58606415,  0.01325621,\n",
       "       -0.05850305, -0.01651212, -0.65983898,  1.20835678, -0.46678407,\n",
       "       -0.71136508, -0.33006161,  0.91687514, -0.61658186, -0.08659175,\n",
       "       -0.27564137, -0.79837028, -0.60942403,  0.91480789, -0.67655783,\n",
       "       -0.16010818, -0.73699893, -0.19016076, -0.14385446, -0.47210723,\n",
       "       -0.46536284, -0.48724981, -0.65120823,  0.29726993,  0.33432531,\n",
       "        0.17199484, -0.77017822,  3.39007619,  1.74377341,  2.79057494,\n",
       "       -0.24331482,  0.03496229,  0.53650193, -0.68746255,  3.14769163,\n",
       "        0.51066136, -0.21326223, -0.55650254, -0.24132509, -0.80955925,\n",
       "       -0.41652416, -0.16052163, -0.80707855,  0.54632135, -0.78868007,\n",
       "       -0.62808092, -0.76782673, -0.46618974,  0.41574895, -0.42479315,\n",
       "        0.0923542 ,  0.26367719, -0.55758784, -0.68203603, -0.80116106,\n",
       "       -0.63363664, -0.13519787, -0.59151651, -0.73759326,  0.034523  ,\n",
       "        1.35254717, -0.70361291])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_scaled = Standard_Scaler(X)\n",
    "X_scaled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dividing the scaled features and actual values into training and test sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_scld,X_test_scld,Y_train,Y_test = train_test_split(X_scaled,Y,test_size = 0.3,random_state = 42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running Gradient descent on scaled features:\n",
    "\n",
    "        here learning rate is initialized with a higher value (0.005 to 0.02) as X is now scaled \n",
    "        thus changes in X will not change the theta value too much hence with alpha = 0.005\n",
    "        gradient decent would require more iterations \n",
    "        alpha can be 0.03 ,0.05, 0.1, 0.5 ,1 in order to reduce the number of iterations required,\n",
    "        however with higher alpha value gradient descent may diverge quickly \n",
    "        (one can initialize alpha with different value and select the one which suitd the model best)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Theta value we got after 100 iteration\n",
      "\n",
      "[[5.05349076]\n",
      " [4.26621497]]\n",
      "-------------------------------------\n",
      "change in cost with iteration\n",
      "\n",
      "[6.11901761e-01 5.78491433e-01 5.46663657e-01 5.16350283e-01\n",
      " 4.87485983e-01 4.60008133e-01 4.33856703e-01 4.08974156e-01\n",
      " 3.85305342e-01 3.62797401e-01 3.41399673e-01 3.21063606e-01\n",
      " 3.01742672e-01 2.83392280e-01 2.65969704e-01 2.49434002e-01\n",
      " 2.33745942e-01 2.18867937e-01 2.04763976e-01 1.91399556e-01\n",
      " 1.78741627e-01 1.66758525e-01 1.55419922e-01 1.44696767e-01\n",
      " 1.34561236e-01 1.24986680e-01 1.15947577e-01 1.07419488e-01\n",
      " 9.93790090e-02 9.18037317e-02 8.46722003e-02 7.79638735e-02\n",
      " 7.16590863e-02 6.57390140e-02 6.01856378e-02 5.49817113e-02\n",
      " 5.01107287e-02 4.55568940e-02 4.13050920e-02 3.73408598e-02\n",
      " 3.36503600e-02 3.02203547e-02 2.70381805e-02 2.40917249e-02\n",
      " 2.13694033e-02 1.88601367e-02 1.65533313e-02 1.44388579e-02\n",
      " 1.25070323e-02 1.07485973e-02 9.15470438e-03 7.71689670e-03\n",
      " 6.42709287e-03 5.27757104e-03 4.26095388e-03 3.37019407e-03\n",
      " 2.59856045e-03 1.93962467e-03 1.38724845e-03 9.35571322e-04\n",
      " 5.78998886e-04 3.12191544e-04 1.30053707e-04 2.77234362e-05\n",
      " 5.62511035e-07 4.41469089e-05 1.54257674e-04 3.26872164e-04\n",
      " 5.58155654e-04 8.44453295e-04 1.18228239e-03 1.56832501e-03\n",
      " 1.99942088e-03 2.47256061e-03 2.98487918e-03 3.53364964e-03\n",
      " 4.11627720e-03 4.73029344e-03 5.37335081e-03 6.04321739e-03\n",
      " 6.73777182e-03 7.45499843e-03 8.19298267e-03 8.94990659e-03\n",
      " 9.72404460e-03 1.05137594e-02 1.13174982e-02 1.21337885e-02\n",
      " 1.29612352e-02 1.37985166e-02 1.46443813e-02 1.54976452e-02\n",
      " 1.63571881e-02 1.72219512e-02 1.80909341e-02 1.89631920e-02\n",
      " 1.98378337e-02 2.07140186e-02 2.15909545e-02 2.24678957e-02]\n"
     ]
    }
   ],
   "source": [
    "alpha = 0.02\n",
    "n = np.size(X[1])+1                          # no of features in X + 1 for X0 term which will be added\n",
    "initial_Theta = np.zeros((1,n),dtype=float)  # initialize theta vector with all 0's\n",
    "iterations = 100\n",
    "theta,cost_history=GradientDescent(x=X_train_scld,y=Y_train,theta=initial_Theta,alpha=alpha,num_iterations=iterations)\n",
    "print(\"Theta value we got after 100 iteration\\n\")\n",
    "print(theta)\n",
    "print(\"-------------------------------------\")\n",
    "print(\"change in cost with iteration\\n\")\n",
    "print(cost_history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Find the optimal num of iterations required for Convergence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_dpi = 100 # dots per inch .. (resolution)\n",
    "plt.figure(figsize=(1000/my_dpi, 400/my_dpi), dpi = my_dpi) # to enlarge the plot (can be omitted)\n",
    "\n",
    "plt.plot(np.arange(0,iterations,step=1),cost_history,linewidth=1,label=\"mean sq error\")\n",
    "plt.xticks(np.arange(0,iterations,step=5))\n",
    "plt.xlabel('Iterations')\n",
    "plt.ylabel('Mean squared error')\n",
    "plt.legend()\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Trying to visualize the covergence point better"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_dpi = 100 # dots per inch .. (resolution)\n",
    "plt.figure(figsize=(1000/my_dpi, 400/my_dpi), dpi = my_dpi) # to enlarge the plot (can be omitted)\n",
    "\n",
    "plt.plot(np.arange(55,70,step=1),cost_history[55:70],linewidth=1,label=\"mean Sq error\")\n",
    "plt.xticks(np.arange(55,70,step=1))\n",
    "plt.xlabel('Iterations')\n",
    "plt.ylabel('Mean squared error')\n",
    "plt.ylim(0,0.005)\n",
    "plt.yticks(np.arange(0,0.005,step=0.001))\n",
    "plt.legend()\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inference :\n",
    "\n",
    "    we see after on 65th iteration(as interation starts from 0) the error is minimum, and increases again \n",
    "    when iterations are increased.\n",
    "    Hence we select number of iterations = 65"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal value of theta\n",
      "\n",
      "[[4.28119483]\n",
      " [3.58643217]]\n",
      "-------------------------------------\n",
      "final Mean squared error: 0.000000563 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "alpha = 0.02\n",
    "n = np.size(X[1])+1                          # no of features in X + 1 for X0 term which will be added\n",
    "initial_Theta = np.zeros((1,n),dtype=float)  # initialize theta vector with all 0's\n",
    "iterations = 65                              # best value of iteration from graph\n",
    "optimized_theta,cost_history=GradientDescent(x=X_train_scld,y=Y_train,theta=initial_Theta,alpha=alpha,num_iterations=iterations)\n",
    "print(\"Optimal value of theta\\n\")\n",
    "print(optimized_theta)\n",
    "print(\"-------------------------------------\")\n",
    "print(\"final Mean squared error: %.9f \\n\" %cost_history[-1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Predicting Y from X in test Set(X_test):\n",
    "\n",
    "        first checking with a single test case\n",
    "        Here we will be predicting for the 10th example(row) in the test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  3.39007619],\n",
       "       [ 1.        , -0.71136508],\n",
       "       [ 1.        , -0.73759326],\n",
       "       [ 1.        , -0.44709356],\n",
       "       [ 1.        , -0.76782673]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "finalX_test_scaled = addX0(X_test_scld) # the bias/intercept term from theta0 , X0 needs to be added\n",
    "finalX_test_scaled[0:5] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.929000000000002"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "actual_value = Y_test[0]\n",
    "actual_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Making Prediction of Y given the value of X:\n",
    "\n",
    "        pred = X * Theta; where X is (mXn) Matrix and theta is (nX1) column vector\n",
    "        The result will be a mX1 vector , where m is no of rows in X\n",
    "        Here :\n",
    "        X = (1X2) matrix ; a single row from X_test  \n",
    "        optimized_theta = (2X1) column vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16.439473124090856"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted_value = finalX_test_scaled[0] @ optimized_theta\n",
    "predicted_value[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prediction for entire Test set and ploting it as the best fit line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "rows = len(finalX_test_scaled)\n",
    "pred = np.zeros((rows),dtype=float)\n",
    "pred               \n",
    "for i in range(rows):\n",
    "    pred[i] = finalX_test_scaled[i] @ optimized_theta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x6d9fc6e240>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_dpi = 100 # dots per inch .. (resolution)\n",
    "plt.figure(figsize=(1000/my_dpi, 400/my_dpi), dpi = my_dpi) # to enlarge the plot (can be omitted)\n",
    "\n",
    "plt.scatter(X_test_scld,Y_test,color='r',s=5,label = 'Test set(xi,yi)')\n",
    "plt.plot(X_test_scld,pred,'g-',linewidth=0.5,label = 'prediction(yi)=theta0 + theta1*xi')\n",
    "plt.xlabel(\"X (Scaled_features)\")\n",
    "plt.ylabel('Y (Actual values)')\n",
    "plt.title('Linear Regression with Feature scaling')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Entension / Future works:\n",
    "\n",
    "        The above is an example of single variable Linear Regression , so with minor modifications one can change this code \n",
    "        to supoort multi variable Linear regression.\n",
    "        The feature scaling method used here is Stadardization\n",
    "        one can also use a normalization for feature scaling depending on the data set they use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}