ADVANCE_GRADIENT_ALGORITHMS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8fa15e78",
   "metadata": {},
   "source": [
    "# Importing Liabraries\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c7209ba0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np# Importing Liabraries\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import preprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59c7c051",
   "metadata": {},
   "source": [
    "# Loading the Dataset "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4663b468",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       area  bedrooms   price\n",
      "0    1056.0         2   39.07\n",
      "1    2600.0         5  120.00\n",
      "2    1440.0         2   62.00\n",
      "3    1521.0         3   95.00\n",
      "4    1200.0         2   51.00\n",
      "..      ...       ...     ...\n",
      "294  1425.0         2   70.00\n",
      "295  1450.0         3  100.00\n",
      "296  1847.0         3  105.00\n",
      "297  1100.0         2   45.00\n",
      "298   525.0         1   26.00\n",
      "\n",
      "[299 rows x 3 columns]\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv(\"Bengaluru_House_Data.csv\")\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eaeb4728",
   "metadata": {},
   "source": [
    "# Scaling the factors\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "38315fb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.03747664],\n",
       "       [0.14552737],\n",
       "       [0.06809079],\n",
       "       [0.11214953],\n",
       "       [0.05340454],\n",
       "       [0.03604806],\n",
       "       [0.2576769 ],\n",
       "       [0.78638184],\n",
       "       [0.06975968],\n",
       "       [0.47930574],\n",
       "       [0.0787717 ],\n",
       "       [0.37917223],\n",
       "       [0.03604806],\n",
       "       [0.03871829],\n",
       "       [0.18291055],\n",
       "       [0.08344459],\n",
       "       [0.0493992 ],\n",
       "       [0.06542056],\n",
       "       [0.37249666],\n",
       "       [0.0493992 ],\n",
       "       [0.00534045],\n",
       "       [0.1481976 ],\n",
       "       [0.49265688],\n",
       "       [0.12283044],\n",
       "       [0.01902537],\n",
       "       [0.06008011],\n",
       "       [0.01615487],\n",
       "       [0.09345794],\n",
       "       [0.05042724],\n",
       "       [0.04806409],\n",
       "       [0.23364486],\n",
       "       [0.03204272],\n",
       "       [0.14953271],\n",
       "       [0.06193591],\n",
       "       [0.15220294],\n",
       "       [0.03337784],\n",
       "       [0.04606142],\n",
       "       [0.15220294],\n",
       "       [0.06024032],\n",
       "       [0.04539386],\n",
       "       [0.09345794],\n",
       "       [0.03604806],\n",
       "       [0.03604806],\n",
       "       [0.0493992 ],\n",
       "       [0.10786382],\n",
       "       [0.25233645],\n",
       "       [0.0293725 ],\n",
       "       [0.11190921],\n",
       "       [0.1588785 ],\n",
       "       [0.03337784],\n",
       "       [0.05206943],\n",
       "       [0.11748999],\n",
       "       [0.10680908],\n",
       "       [0.08544726],\n",
       "       [0.08544726],\n",
       "       [0.04405874],\n",
       "       [0.23230975],\n",
       "       [0.18558077],\n",
       "       [0.04539386],\n",
       "       [0.30574099],\n",
       "       [0.05874499],\n",
       "       [0.85313752],\n",
       "       [0.04405874],\n",
       "       [0.17222964],\n",
       "       [0.06809079],\n",
       "       [0.04272363],\n",
       "       [0.06141522],\n",
       "       [0.0987984 ],\n",
       "       [0.03428571],\n",
       "       [0.1188251 ],\n",
       "       [0.0928972 ],\n",
       "       [0.12016021],\n",
       "       [0.0787717 ],\n",
       "       [0.17222964],\n",
       "       [0.04970628],\n",
       "       [0.03871829],\n",
       "       [0.25901202],\n",
       "       [0.01468625],\n",
       "       [0.31909212],\n",
       "       [0.12550067],\n",
       "       [0.0894526 ],\n",
       "       [0.06648865],\n",
       "       [0.12149533],\n",
       "       [0.26568758],\n",
       "       [0.10280374],\n",
       "       [0.03471295],\n",
       "       [0.06283044],\n",
       "       [0.19893191],\n",
       "       [0.0787717 ],\n",
       "       [0.02387183],\n",
       "       [0.0787717 ],\n",
       "       [0.19225634],\n",
       "       [0.09212283],\n",
       "       [0.10547397],\n",
       "       [0.31241656],\n",
       "       [0.0493992 ],\n",
       "       [0.07209613],\n",
       "       [0.10547397],\n",
       "       [0.16955941],\n",
       "       [0.00801068],\n",
       "       [0.18558077],\n",
       "       [0.04272363],\n",
       "       [0.05206943],\n",
       "       [0.05193591],\n",
       "       [0.11615487],\n",
       "       [0.29105474],\n",
       "       [0.05965287],\n",
       "       [0.07447263],\n",
       "       [0.14552737],\n",
       "       [0.08544726],\n",
       "       [0.05461949],\n",
       "       [0.04659546],\n",
       "       [0.28571429],\n",
       "       [0.17222964],\n",
       "       [0.07076101],\n",
       "       [0.08511348],\n",
       "       [0.08544726],\n",
       "       [0.01602136],\n",
       "       [0.14552737],\n",
       "       [0.25233645],\n",
       "       [0.18558077],\n",
       "       [0.03070761],\n",
       "       [0.07209613],\n",
       "       [0.05740988],\n",
       "       [0.0894526 ],\n",
       "       [0.1388518 ],\n",
       "       [0.13217623],\n",
       "       [0.08544726],\n",
       "       [0.00734312],\n",
       "       [0.26568758],\n",
       "       [0.09612817],\n",
       "       [0.06141522],\n",
       "       [0.07209613],\n",
       "       [0.05260347],\n",
       "       [0.09886515],\n",
       "       [0.31909212],\n",
       "       [0.26969292],\n",
       "       [0.12550067],\n",
       "       [0.06542056],\n",
       "       [0.04373832],\n",
       "       [0.28571429],\n",
       "       [0.13217623],\n",
       "       [0.03204272],\n",
       "       [0.04771696],\n",
       "       [0.23230975],\n",
       "       [0.10722296],\n",
       "       [0.06275033],\n",
       "       [0.04405874],\n",
       "       [0.29906542],\n",
       "       [0.05206943],\n",
       "       [0.02616822],\n",
       "       [0.05206943],\n",
       "       [0.16555407],\n",
       "       [0.17890521],\n",
       "       [1.        ],\n",
       "       [0.0493992 ],\n",
       "       [0.02803738],\n",
       "       [0.18558077],\n",
       "       [0.54606142],\n",
       "       [0.21895861],\n",
       "       [0.08544726],\n",
       "       [0.07142857],\n",
       "       [0.06542056],\n",
       "       [0.0787717 ],\n",
       "       [0.11748999],\n",
       "       [0.        ],\n",
       "       [0.07142857],\n",
       "       [0.06008011],\n",
       "       [0.07209613],\n",
       "       [0.1188251 ],\n",
       "       [0.0987984 ],\n",
       "       [0.00400534],\n",
       "       [0.07476636],\n",
       "       [0.03337784],\n",
       "       [0.05340454],\n",
       "       [0.19225634],\n",
       "       [0.17890521],\n",
       "       [0.13217623],\n",
       "       [0.05473965],\n",
       "       [0.3858478 ],\n",
       "       [0.05967957],\n",
       "       [0.04672897],\n",
       "       [0.05473965],\n",
       "       [0.13217623],\n",
       "       [0.09212283],\n",
       "       [0.41922563],\n",
       "       [0.31909212],\n",
       "       [0.06542056],\n",
       "       [0.11615487],\n",
       "       [0.06275033],\n",
       "       [0.1388518 ],\n",
       "       [0.06008011],\n",
       "       [0.0493992 ],\n",
       "       [0.09479306],\n",
       "       [0.0787717 ],\n",
       "       [0.04886515],\n",
       "       [0.05607477],\n",
       "       [0.05740988],\n",
       "       [0.05033378],\n",
       "       [0.10280374],\n",
       "       [0.10146862],\n",
       "       [0.04339119],\n",
       "       [0.23898531],\n",
       "       [0.55674232],\n",
       "       [0.07209613],\n",
       "       [0.10413885],\n",
       "       [0.08983979],\n",
       "       [0.1188251 ],\n",
       "       [0.07209613],\n",
       "       [0.17356475],\n",
       "       [0.02136182],\n",
       "       [0.0894526 ],\n",
       "       [0.11654206],\n",
       "       [0.15220294],\n",
       "       [0.10547397],\n",
       "       [0.08611482],\n",
       "       [0.04443258],\n",
       "       [0.33244326],\n",
       "       [0.08144192],\n",
       "       [0.1388518 ],\n",
       "       [0.14419226],\n",
       "       [0.01487316],\n",
       "       [0.06061415],\n",
       "       [0.06542056],\n",
       "       [0.05874499],\n",
       "       [0.04138852],\n",
       "       [0.13217623],\n",
       "       [0.07209613],\n",
       "       [0.03738318],\n",
       "       [0.15754339],\n",
       "       [0.18558077],\n",
       "       [0.06542056],\n",
       "       [0.00727637],\n",
       "       [0.22563418],\n",
       "       [0.00727637],\n",
       "       [0.09746328],\n",
       "       [0.08210948],\n",
       "       [0.10547397],\n",
       "       [0.03871829],\n",
       "       [0.0787717 ],\n",
       "       [0.35914553],\n",
       "       [0.23230975],\n",
       "       [0.01201602],\n",
       "       [0.05874499],\n",
       "       [0.10947931],\n",
       "       [0.01535381],\n",
       "       [0.07743658],\n",
       "       [0.11214953],\n",
       "       [0.03337784],\n",
       "       [0.0694259 ],\n",
       "       [0.21228304],\n",
       "       [0.21228304],\n",
       "       [0.3858478 ],\n",
       "       [0.08611482],\n",
       "       [0.04392523],\n",
       "       [0.06528705],\n",
       "       [0.05100134],\n",
       "       [0.05580774],\n",
       "       [0.04672897],\n",
       "       [0.06753004],\n",
       "       [0.0200267 ],\n",
       "       [0.14552737],\n",
       "       [0.02803738],\n",
       "       [0.16021362],\n",
       "       [0.04539386],\n",
       "       [0.13217623],\n",
       "       [0.08404539],\n",
       "       [0.16154873],\n",
       "       [0.09332443],\n",
       "       [0.31909212],\n",
       "       [0.10740988],\n",
       "       [0.05874499],\n",
       "       [0.03137517],\n",
       "       [0.1188251 ],\n",
       "       [0.31909212],\n",
       "       [0.09052069],\n",
       "       [0.04672897],\n",
       "       [0.11081442],\n",
       "       [0.03871829],\n",
       "       [0.06008011],\n",
       "       [0.05206943],\n",
       "       [0.01986649],\n",
       "       [0.05373832],\n",
       "       [0.04405874],\n",
       "       [0.04539386],\n",
       "       [0.1164219 ],\n",
       "       [0.05206943],\n",
       "       [0.08544726],\n",
       "       [0.11615487],\n",
       "       [0.04806409],\n",
       "       [0.14552737],\n",
       "       [0.17222964],\n",
       "       [0.12416555],\n",
       "       [0.0246996 ],\n",
       "       [0.0787717 ],\n",
       "       [0.1188251 ],\n",
       "       [0.12550067],\n",
       "       [0.04539386],\n",
       "       [0.0200267 ]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#The dataset should be Scaled before Training and dropping the target variable as Price\n",
    "sx=preprocessing.MinMaxScaler()\n",
    "sy=preprocessing.MinMaxScaler()\n",
    "\n",
    "scaled_X= sx.fit_transform(df.drop('price' , axis='columns'))\n",
    "scaled_X\n",
    "\n",
    "scaled_Y= sy.fit_transform(df['price'].values.reshape(df.shape[0],1))\n",
    "scaled_Y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7ef5b1c",
   "metadata": {},
   "source": [
    "# Momentum Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f613d432",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Momentum Weights: [0.5036555  0.18271348]\n",
      "Momentum Bias: -0.03519693646463169\n",
      "Momentum Final Cost: 0.00622344749655487\n"
     ]
    }
   ],
   "source": [
    "def gradient_momentum(X, y_true, epochs, learning_rate=0.01, momentum=0.9):\n",
    "    number = X.shape[1]\n",
    "    w = np.ones(shape=(number,))\n",
    "    b = 0\n",
    "    v_w = np.zeros_like(w)\n",
    "    v_b = 0\n",
    "    \n",
    "    cost_list = []\n",
    "    epoch_list = []\n",
    "    \n",
    "    for epoch in range(epochs):\n",
    "        # Predictions\n",
    "        y_predicted = np.dot(X, w) + b\n",
    "        \n",
    "        # Gradients\n",
    "        w_grad = -(2 / X.shape[0]) * np.dot(X.T, (y_true - y_predicted))\n",
    "        b_grad = -(2 / X.shape[0]) * np.sum(y_true - y_predicted)\n",
    "        \n",
    "        # Update velocities\n",
    "        v_w = momentum * v_w + learning_rate * w_grad\n",
    "        v_b = momentum * v_b + learning_rate * b_grad\n",
    "        \n",
    "        # Update weights and bias\n",
    "        w -= v_w\n",
    "        b -= v_b\n",
    "        \n",
    "        # Calculate cost\n",
    "        cost = np.mean(np.square(y_true - y_predicted))\n",
    "        \n",
    "        if epoch % 10 == 0:\n",
    "            cost_list.append(cost)\n",
    "            epoch_list.append(epoch)\n",
    "    \n",
    "    return w, b, cost, cost_list, epoch_list\n",
    "\n",
    "# Example usage\n",
    "w_momentum, b_momentum, cost_momentum, cost_list_momentum, epoch_list_momentum = gradient_momentum(scaled_X, scaled_Y.reshape(-1,), epochs=1000)\n",
    "print(f\"Momentum Weights: {w_momentum}\")\n",
    "print(f\"Momentum Bias: {b_momentum}\")\n",
    "print(f\"Momentum Final Cost: {cost_momentum}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d8f51b4",
   "metadata": {},
   "source": [
    "# Adam Optimizer "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5e435b15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adam Weights: [0.62047791 0.53221291]\n",
      "Adam Bias: -0.14574150760845267\n",
      "Adam Final Cost: 0.011038537400405368\n"
     ]
    }
   ],
   "source": [
    "def gradient_adam(X, y_true, epochs, learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8):\n",
    "    number = X.shape[1]\n",
    "    w = np.ones(shape=(number,))\n",
    "    b = 0\n",
    "    m_w = np.zeros_like(w)\n",
    "    m_b = 0\n",
    "    v_w = np.zeros_like(w)\n",
    "    v_b = 0\n",
    "    t = 0\n",
    "    \n",
    "    cost_list = []\n",
    "    epoch_list = []\n",
    "    \n",
    "    for epoch in range(epochs):\n",
    "        t += 1\n",
    "        # Predictions\n",
    "        y_predicted = np.dot(X, w) + b\n",
    "        \n",
    "        # Gradients\n",
    "        w_grad = -(2 / X.shape[0]) * np.dot(X.T, (y_true - y_predicted))\n",
    "        b_grad = -(2 / X.shape[0]) * np.sum(y_true - y_predicted)\n",
    "        \n",
    "        # Update biased first moment estimate\n",
    "        m_w = beta1 * m_w + (1 - beta1) * w_grad\n",
    "        m_b = beta1 * m_b + (1 - beta1) * b_grad\n",
    "        \n",
    "        # Update biased second raw moment estimate\n",
    "        v_w = beta2 * v_w + (1 - beta2) * (w_grad ** 2)\n",
    "        v_b = beta2 * v_b + (1 - beta2) * (b_grad ** 2)\n",
    "        \n",
    "        # Compute bias-corrected first moment estimate\n",
    "        m_w_hat = m_w / (1 - beta1 ** t)\n",
    "        m_b_hat = m_b / (1 - beta1 ** t)\n",
    "        \n",
    "        # Compute bias-corrected second raw moment estimate\n",
    "        v_w_hat = v_w / (1 - beta2 ** t)\n",
    "        v_b_hat = v_b / (1 - beta2 ** t)\n",
    "        \n",
    "        # Update weights and bias\n",
    "        w -= learning_rate * m_w_hat / (np.sqrt(v_w_hat) + epsilon)\n",
    "        b -= learning_rate * m_b_hat / (np.sqrt(v_b_hat) + epsilon)\n",
    "        \n",
    "        # Calculate cost\n",
    "        cost = np.mean(np.square(y_true - y_predicted))\n",
    "        \n",
    "        if epoch % 10 == 0:\n",
    "            cost_list.append(cost)\n",
    "            epoch_list.append(epoch)\n",
    "    \n",
    "    return w, b, cost, cost_list, epoch_list\n",
    "\n",
    "# Example usage\n",
    "w_adam, b_adam, cost_adam, cost_list_adam, epoch_list_adam = gradient_adam(scaled_X, scaled_Y.reshape(-1,), epochs=1000)\n",
    "print(f\"Adam Weights: {w_adam}\")\n",
    "print(f\"Adam Bias: {b_adam}\")\n",
    "print(f\"Adam Final Cost: {cost_adam}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab09e245",
   "metadata": {},
   "source": [
    "# RmSProp Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "e25f9044",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSprop Weights: [0.51712122 0.17249566]\n",
      "RMSprop Bias: -0.03535171701208662\n",
      "RMSprop Final Cost: 0.0062211785101581015\n"
     ]
    }
   ],
   "source": [
    "def gradient_rmsprop(X, y_true, epochs, learning_rate=0.001, beta=0.9, epsilon=1e-8):\n",
    "    number = X.shape[1]\n",
    "    w = np.ones(shape=(number,))\n",
    "    b = 0\n",
    "    v_w = np.zeros_like(w)\n",
    "    v_b = 0\n",
    "    \n",
    "    cost_list = []\n",
    "    epoch_list = []\n",
    "    \n",
    "    for epoch in range(epochs):\n",
    "        # Predictions\n",
    "        y_predicted = np.dot(X, w) + b\n",
    "        \n",
    "        # Gradients\n",
    "        w_grad = -(2 / X.shape[0]) * np.dot(X.T, (y_true - y_predicted))\n",
    "        b_grad = -(2 / X.shape[0]) * np.sum(y_true - y_predicted)\n",
    "        \n",
    "        # Update moving averages of squared gradients\n",
    "        v_w = beta * v_w + (1 - beta) * (w_grad ** 2)\n",
    "        v_b = beta * v_b + (1 - beta) * (b_grad ** 2)\n",
    "        \n",
    "        # Update weights and bias\n",
    "        w -= learning_rate * w_grad / (np.sqrt(v_w) + epsilon)\n",
    "        b -= learning_rate * b_grad / (np.sqrt(v_b) + epsilon)\n",
    "        \n",
    "        # Calculate cost\n",
    "        cost = np.mean(np.square(y_true - y_predicted))\n",
    "        \n",
    "        if epoch % 10 == 0:\n",
    "            cost_list.append(cost)\n",
    "            epoch_list.append(epoch)\n",
    "    \n",
    "    return w, b, cost, cost_list, epoch_list\n",
    "\n",
    "# Example usage\n",
    "w_rmsprop, b_rmsprop, cost_rmsprop, cost_list_rmsprop, epoch_list_rmsprop = gradient_rmsprop(scaled_X, scaled_Y.reshape(-1,), epochs=1000)\n",
    "print(f\"RMSprop Weights: {w_rmsprop}\")\n",
    "print(f\"RMSprop Bias: {b_rmsprop}\")\n",
    "print(f\"RMSprop Final Cost: {cost_rmsprop}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "229c045e",
   "metadata": {},
   "source": [
    "# Comparision of 3 Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6d299d6c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the cost over epochs for each algorithm\n",
    "plt.figure(figsize=(4,4))\n",
    "plt.plot(epoch_list_momentum, cost_list_momentum, label='Momentum', color='blue')\n",
    "plt.plot(epoch_list_adam, cost_list_adam, label='Adam', color='green')\n",
    "plt.plot(epoch_list_rmsprop, cost_list_rmsprop, label='RMSprop', color='red')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Cost')\n",
    "plt.title('Cost over Epochs for Different Optimization Algorithms')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.show()\n",
    "\n",
    "\n",
    "'''\n",
    "1) Momentum : Starts with a high initial cost but decreases rapidly initially and then slows down, converging to a low cost.\n",
    "\n",
    "2) Adam : Starts at a similar point as Momentum but has a slightly faster initial decrease in cost. It converges to the \n",
    "   lowest cost among the three algorithms.\n",
    "\n",
    "3) RMSprop : Has a similar pattern to Adam but converges to a slightly higher cost than Adam.\n",
    "\n",
    "Adam appears to be the most efficient optimizer among the three, as it reaches the lowest cost in the given number of epochs.\n",
    "Momentum and RMSprop also perform well but do not reach as low a cost as Adam within the same number of epochs.\n",
    "'''"
   ]
  }
 ],
 "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}