Batch Gradient Descent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "74dca25d-9107-4eb8-9c7e-cb02a1e2ead2",
   "metadata": {},
   "source": [
    "We will use very simple home prices data set to implement batch and stochastic gradient descent in python. Batch gradient descent uses all training samples in forward pass to calculate cumulitive error and than we adjust weights using derivaties. In stochastic GD, we randomly pick one training sample, perform forward pass, compute the error and immidiately adjust weights. So the key difference here is that to adjust weights batch GD will use all training samples where as stochastic GD will use one randomly picked training sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d129c41a-4e34-41bc-be07-5d3eab14f2de",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "191a9e64-0440-4335-b0a3-a7f4f252f93a",
   "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>area</th>\n",
       "      <th>bedrooms</th>\n",
       "      <th>price</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>1800</td>\n",
       "      <td>3</td>\n",
       "      <td>82.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1521</td>\n",
       "      <td>3</td>\n",
       "      <td>75.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>1180</td>\n",
       "      <td>3</td>\n",
       "      <td>48.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>2250</td>\n",
       "      <td>3</td>\n",
       "      <td>101.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>1540</td>\n",
       "      <td>3</td>\n",
       "      <td>60.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    area  bedrooms  price\n",
       "10  1800         3   82.0\n",
       "3   1521         3   75.0\n",
       "16  1180         3   48.0\n",
       "14  2250         3  101.0\n",
       "17  1540         3   60.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv(\"homeprices_banglore.csv\")\n",
    "df.sample(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbe1c6c8-ce36-4624-9c3e-9b42c39b3581",
   "metadata": {},
   "source": [
    "PreProcessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0d88bcaf-57fe-4a8e-8012-32d9c8632139",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.08827586, 0.25      ],\n",
       "       [0.62068966, 0.75      ],\n",
       "       [0.22068966, 0.5       ],\n",
       "       [0.24862069, 0.5       ],\n",
       "       [0.13793103, 0.25      ],\n",
       "       [0.12758621, 0.25      ],\n",
       "       [0.6662069 , 0.75      ],\n",
       "       [0.86206897, 0.75      ],\n",
       "       [0.17586207, 0.5       ],\n",
       "       [1.        , 1.        ],\n",
       "       [0.34482759, 0.5       ],\n",
       "       [0.68448276, 0.75      ],\n",
       "       [0.06896552, 0.25      ],\n",
       "       [0.10344828, 0.25      ],\n",
       "       [0.5       , 0.5       ],\n",
       "       [0.12931034, 0.25      ],\n",
       "       [0.13103448, 0.5       ],\n",
       "       [0.25517241, 0.5       ],\n",
       "       [0.67931034, 0.5       ],\n",
       "       [0.        , 0.        ]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import preprocessing \n",
    "\n",
    "sx = preprocessing.MinMaxScaler()\n",
    "sy = preprocessing.MinMaxScaler()\n",
    "\n",
    "scaled_x = sx.fit_transform(df.drop('price',axis='columns'))\n",
    "scaled_y = sy.fit_transform(df['price'].values.reshape(df.shape[0],1))\n",
    "\n",
    "scaled_x                             "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fda19bd3-d0bb-4922-b3c7-4faa83cd8085",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.05237037],\n",
       "       [0.65185185],\n",
       "       [0.22222222],\n",
       "       [0.31851852],\n",
       "       [0.14074074],\n",
       "       [0.04444444],\n",
       "       [0.76296296],\n",
       "       [0.91111111],\n",
       "       [0.13333333],\n",
       "       [1.        ],\n",
       "       [0.37037037],\n",
       "       [0.8       ],\n",
       "       [0.04444444],\n",
       "       [0.05925926],\n",
       "       [0.51111111],\n",
       "       [0.07407407],\n",
       "       [0.11851852],\n",
       "       [0.20740741],\n",
       "       [0.51851852],\n",
       "       [0.        ]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scaled_y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30f5365e-0dae-42e6-9bee-f7d2095b7afe",
   "metadata": {},
   "source": [
    "We need to make the Price column a 1D vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c84ce042-a982-44ca-9ee0-9c606b3b6cea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.05237037, 0.65185185, 0.22222222, 0.31851852, 0.14074074,\n",
       "       0.04444444, 0.76296296, 0.91111111, 0.13333333, 1.        ,\n",
       "       0.37037037, 0.8       , 0.04444444, 0.05925926, 0.51111111,\n",
       "       0.07407407, 0.11851852, 0.20740741, 0.51851852, 0.        ])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scaled_y.reshape(20,)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36916a1e-c318-4595-8879-e3783effb1b2",
   "metadata": {},
   "source": [
    "Implementation of Batch Gradient Descent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "3333e81e-0d97-4715-bc95-995bc2501408",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.70712464, 0.67456527]), -0.23034857438407427, 0.0068641890429808105)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def batch_gradient_descent(x, y_true, epochs, learning_rate = 0.01):\n",
    "\n",
    "    number_of_features = x.shape[1]\n",
    "    # numpy array with 1 row and columns equal to number of features. In \n",
    "    # our case number_of_features = 2 (area, bedroom)\n",
    "    w = np.ones(shape=(number_of_features)) \n",
    "    b = 0\n",
    "    total_samples = x.shape[0] # number of rows in X\n",
    "    \n",
    "    cost_list = []\n",
    "    epoch_list = []\n",
    "    \n",
    "    for i in range(epochs):        \n",
    "        y_predicted = np.dot(w, x.T) + b\n",
    "\n",
    "        w_grad = -(2/total_samples)*(x.T.dot(y_true-y_predicted))\n",
    "        b_grad = -(2/total_samples)*np.sum(y_true-y_predicted)\n",
    "        \n",
    "        w = w - learning_rate * w_grad\n",
    "        b = b - learning_rate * b_grad\n",
    "        \n",
    "        cost = np.mean(np.square(y_true-y_predicted)) # MSE (Mean Squared Error)\n",
    "        \n",
    "        if i%10==0:\n",
    "            cost_list.append(cost)\n",
    "            epoch_list.append(i)\n",
    "        \n",
    "    return w, b, cost, cost_list, epoch_list\n",
    "\n",
    "w, b, cost, cost_list, epoch_list = batch_gradient_descent(scaled_x,scaled_y.reshape(scaled_y.shape[0],),500)\n",
    "w, b, cost"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "141b8bec-8214-4f9a-9d9d-ce3ef348401d",
   "metadata": {},
   "source": [
    "Check price equation above. In that equation we were trying to find values of w1,w2 and bias. Here we got these values for each of them,\n",
    "\n",
    "w1 = 0.66469087 w2 = 0.60541671 bias = -0.17792104056392882\n",
    "------------------------------------------------------------\n",
    "\n",
    "Now plot epoch vs cost graph to see how cost reduces as number of epoch increases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "cc89360f-3200-459a-b505-c08b7e143282",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x27c60f98f50>]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.xlabel(\"epoch\")\n",
    "plt.ylabel(\"cost\")\n",
    "plt.plot(epoch_list,cost_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "8b461e4d-3f09-4856-962d-a216408d39ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(area,bedrooms,w,b):\n",
    "    scaled_x = sx.transform([[area, bedrooms]])[0]\n",
    "\n",
    "    scaled_price = w[0]*scaled_x[0] + w[1]*scaled_x[1] + b\n",
    "\n",
    "    return sy.inverse_transform([[scaled_price]])[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "4f81159e-0522-4b40-92a3-476d22d5c95c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Asus\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\base.py:493: UserWarning: X does not have valid feature names, but MinMaxScaler was fitted with feature names\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "128.45484403267596"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict(2600,4,w,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "d23c7523-8e03-4c60-ba8f-13e6012bcd20",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Asus\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\base.py:493: UserWarning: X does not have valid feature names, but MinMaxScaler was fitted with feature names\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "30.253094462442355"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict(1000,2,w,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d82d3e4c-4f8c-4687-8d82-09fd6be98392",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d127ec6-90ee-47ba-b54f-cf2d156c4115",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}