optimizers.ipynb

{
 "cells": [
  {
   "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",
    "from sklearn.datasets import load_diabetes, make_regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "eps = 1E-5\n",
    "batch_size = 20\n",
    "\n",
    "# learning rate\n",
    "alpha = 0.01\n",
    "\n",
    "# momentum parameter\n",
    "gamma = 0.8\n",
    "\n",
    "# AdaGrad parameter \n",
    "delta = 0.9\n",
    "\n",
    "# decay parameters for RMSProp and Adam\n",
    "rho_s = 0.5\n",
    "rho_r = 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1000, 10), (1000,))"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load diabetes data\n",
    "# data = load_diabetes()\n",
    "# X = data['data']\n",
    "# Y = data['target']\n",
    "\n",
    "# make regression data\n",
    "data = make_regression(n_samples=1000, n_features=10, random_state=42)\n",
    "X = data[0]\n",
    "Y = data[1]\n",
    "\n",
    "logger = {}\n",
    "X.shape, Y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following are loss and gradient calculation functions. They do not change with optimizers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss_fn(theta,X,Y):\n",
    "    return (Y-X@theta).T @ (Y-X@theta)\n",
    "\n",
    "def gradient(theta,X,Y):\n",
    "    dtheta = 2 * X.T @ X @ theta - 2 * X.T @ Y \n",
    "    return theta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Gradient Descent\n",
    "\n",
    "This is the most basic optimizer. Updates happen per epoch i.e. after all the examples have been seen. However, computing gradients can be computationally costly, time-consuming and can lead to memory issues as it's been done over the complete batch of data, we use Stochastic Gradient Descent which makes updates per batch and not per epoch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_descent(theta_init, X, Y, alpha, eps):\n",
    "    theta = theta_init\n",
    "    dtheta = np.random.random(theta_init.shape)\n",
    "    norm_thetas = []\n",
    "    costs = []\n",
    "    n_iter = 0\n",
    "\n",
    "    while np.linalg.norm(dtheta)>eps:\n",
    "        dtheta = gradient(theta,X,Y)\n",
    "        theta -= alpha * dtheta\n",
    "        cost = loss_fn(theta,X,Y)\n",
    "        norm_thetas.append(np.linalg.norm(theta))\n",
    "        costs.append(cost)\n",
    "        n_iter += 1\n",
    "        \n",
    "    print(f'Converged in {n_iter} updates and {len(costs)} epochs..')\n",
    "    return n_iter, norm_thetas, costs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Stochastic Gradient Descent\n",
    "\n",
    "Here, updates are made per batch of data. The total number of updates are **n_epochs * n_batch_runs**, where n_batch_runs is the number of batch runs. However, since the updates are made per batch which is small fraction of complete data, the updates are noisy but are faster. This helps in speeding the optimizing process but can compromise on accuracy compared to Gradient Descent.\n",
    "\n",
    "In Stochastic Gradient Descent, we have three variations:\n",
    "1. **No Momentum** - Basic SGD\n",
    "2. **Momentum** - As we know that the updates in SGD are noisy, fluctuating heavily in the search space, momentum uses Exponential Moving Averages of gradients from past iterations to overcome oscillations, thereby converging faster.\n",
    "3. **Nestrov Momentum** - It has an added step over the momentum strategy that is to use theta updated interimly for calculating gradients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stochastic_gradient_descent(theta_init, vel_init, batch_size, X, Y, alpha, eps, gamma, momentum=False, nestrov=False):\n",
    "    theta = theta_init\n",
    "    vel = vel_init\n",
    "    dtheta = np.random.random(theta_init.shape)\n",
    "    \n",
    "    norm_thetas = []\n",
    "    costs = []\n",
    "    n_iter = 0\n",
    "\n",
    "    batch_run = int(len(X) / batch_size) + 1\n",
    "    while np.linalg.norm(dtheta)>eps:\n",
    "        for batch_idx in range(batch_run):\n",
    "            X_batch = X[batch_size*batch_idx: min(batch_size*(batch_idx+1), len(X))]\n",
    "            Y_batch = Y[batch_size*batch_idx: min(batch_size*(batch_idx+1), len(Y))]\n",
    "\n",
    "            if not nestrov:\n",
    "                dtheta = gradient(theta,X_batch,Y_batch)\n",
    "                if momentum:\n",
    "                    vel = gamma * vel - alpha * dtheta\n",
    "                    theta += vel    \n",
    "            else:\n",
    "                theta += gamma * vel\n",
    "                dtheta = gradient(theta,X_batch,Y_batch)\n",
    "                vel = gamma * vel - alpha * dtheta\n",
    "            theta -= alpha * dtheta                \n",
    "            n_iter += 1\n",
    "            \n",
    "        cost = loss_fn(theta,X,Y)\n",
    "        norm_thetas.append(np.linalg.norm(theta))\n",
    "        costs.append(cost)\n",
    "    print(f'Converged in {n_iter} updates and {len(costs)} epochs..')\n",
    "    return n_iter, norm_thetas, costs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. AdaGrad\n",
    "\n",
    "Consider a case if we are optimizing two variables such as weight (in kg) and height (in m). The ranges of these variables are significantly different i.e. weights would range 0-100 kg typically and heights would range 0-2 m typically. Optimizing these variables with the same learning rate is not the best idea because search spaces for variables are different and optimization within smaller search spaces can be done faster. \n",
    "\n",
    "Now in order to optimize these variables, we can do the following:\n",
    "\n",
    "1. Normalize variables such that their ranges are similar, as done in **Batch Normalization**\n",
    "2. Use different learning rates for different variables - **AdaGrad**\n",
    "\n",
    "AdaGrad downscales learning rates based on historical gradient values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def adagrad(theta_init, X, Y, alpha, eps, delta):\n",
    "    theta = theta_init\n",
    "    dtheta = np.random.random(theta_init.shape)\n",
    "    norm_thetas = []\n",
    "    costs = []\n",
    "    n_iter = 0\n",
    "    r = np.zeros(dtheta.shape)\n",
    "\n",
    "    while np.linalg.norm(dtheta)>eps:\n",
    "        dtheta = gradient(theta,X,Y)\n",
    "        r+=(dtheta)**2\n",
    "        theta -= np.multiply(alpha / (delta + np.sqrt(r)), dtheta)\n",
    "        cost = loss_fn(theta,X,Y)\n",
    "        norm_thetas.append(np.linalg.norm(theta))\n",
    "        costs.append(cost)\n",
    "        n_iter += 1\n",
    "        \n",
    "    print(f'Converged in {n_iter} updates and {len(costs)} epochs..')\n",
    "    return n_iter, norm_thetas, costs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. RMSProp\n",
    "\n",
    "One of the problems that AdaGrad faces is that the denominator can keep increasing leading to shallowing learning rate too much. RMSProp resolves this issue with exponential moving averages to weigh down past gradients as we move away from those."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def RMSProp(theta_init, X, Y, alpha, eps, delta, rho_r):\n",
    "    theta = theta_init\n",
    "    dtheta = np.random.random(theta_init.shape)\n",
    "    norm_thetas = []\n",
    "    costs = []\n",
    "    n_iter = 0\n",
    "    r = np.zeros(dtheta.shape)\n",
    "\n",
    "    while np.linalg.norm(dtheta)>eps:\n",
    "        dtheta = gradient(theta,X,Y)\n",
    "        r = rho_r * r + (1-rho_r)*(dtheta)**2\n",
    "        theta -= np.multiply(alpha / (delta + np.sqrt(r)), dtheta)\n",
    "        cost = loss_fn(theta,X,Y)\n",
    "        norm_thetas.append(np.linalg.norm(theta))\n",
    "        costs.append(cost)\n",
    "        n_iter += 1\n",
    "        \n",
    "    print(f'Converged in {n_iter} updates and {len(costs)} epochs..')\n",
    "    return n_iter, norm_thetas, costs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Adam \n",
    "Adam is commonly seen as combination of RMSProp and Momentum. Incorporates exponential moving averages of first and second order moments which can be seen equivalent to Momentum and RMSProp strategy respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Adam(theta_init, X, Y, alpha, eps, delta, rho_s, rho_r):\n",
    "    theta = theta_init\n",
    "    dtheta = np.random.random(theta_init.shape)\n",
    "    norm_thetas = []\n",
    "    costs = []\n",
    "    n_iter = 0\n",
    "    s = np.zeros(dtheta.shape)\n",
    "    r = np.zeros(dtheta.shape)\n",
    "\n",
    "    while np.linalg.norm(dtheta)>eps:\n",
    "        dtheta = gradient(theta,X,Y)\n",
    "        s = rho_s * s + (1-rho_s) * dtheta\n",
    "        r = rho_r * r + (1-rho_r) * dtheta * dtheta\n",
    "        s = s / (1-rho_s)\n",
    "        r = r / (1-rho_r)\n",
    "        theta -= np.multiply(alpha * s / (delta + np.sqrt(r)), dtheta)\n",
    "        cost = loss_fn(theta,X,Y)\n",
    "        norm_thetas.append(np.linalg.norm(theta))\n",
    "        costs.append(cost)\n",
    "        n_iter += 1\n",
    "        \n",
    "    print(f'Converged in {n_iter} updates and {len(costs)} epochs..')\n",
    "    return n_iter, norm_thetas, costs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotting(logger, var, methods):\n",
    "    plt.title(var)\n",
    "    plt.xlabel('epochs')\n",
    "    plt.ylabel('loss')\n",
    "    for method in methods:\n",
    "        plt.plot(logger[method][var], label=method)\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run(X, Y, alpha, gamma, delta, eps, rho_s, rho_r, batch_size, logger, method):\n",
    "    theta_init = np.random.random(X.shape[1])\n",
    "    vel_init = np.random.random(X.shape[1])\n",
    "    \n",
    "    print(f'\\nRunning {method}..')\n",
    "    # Gradient Descent\n",
    "    if method=='Gradient Descent':\n",
    "        n_iter, norm_thetas, costs = gradient_descent(theta_init, X, Y, alpha, eps)          \n",
    "    \n",
    "    # Stochastic (min-batch) gradient descent        \n",
    "    elif method=='Stochastic Gradient Descent':\n",
    "        n_iter, norm_thetas, costs = stochastic_gradient_descent(theta_init, vel_init, batch_size, X, Y, alpha, \\\n",
    "                                                                            eps, gamma, momentum=False, nestrov=False)\n",
    "    \n",
    "    # Stochastic gradient descent with Momentum        \n",
    "    elif method=='Momentum':\n",
    "        n_iter, norm_thetas, costs = stochastic_gradient_descent(theta_init, vel_init, batch_size, X, Y, alpha, \\\n",
    "                                                                            eps, gamma, momentum=True, nestrov=False)\n",
    "    \n",
    "    # Stochastic gradient descent with Nestrov Momentum         \n",
    "    elif method=='Nestrov Momentum':\n",
    "        n_iter, norm_thetas, costs = stochastic_gradient_descent(theta_init, vel_init, batch_size, X, Y, alpha, \\\n",
    "                                                                            eps, gamma, momentum=False, nestrov=True)\n",
    "\n",
    "    # AdaGrad         \n",
    "    elif method=='Adagrad':\n",
    "        n_iter, norm_thetas, costs = adagrad(theta_init, X, Y, alpha, eps, delta)\n",
    "    \n",
    "    # RMSProp        \n",
    "    elif method=='RMSProp':\n",
    "        n_iter, norm_thetas, costs = RMSProp(theta_init, X, Y, alpha, eps, delta, rho_r)\n",
    "    \n",
    "    # Adam        \n",
    "    elif method=='Adam':\n",
    "        n_iter, norm_thetas, costs = Adam(theta_init, X, Y, alpha, eps, delta, rho_s, rho_r) \n",
    "    \n",
    "    # logging results       \n",
    "    logger[method] = {}\n",
    "    logger[method]['n_updates'] = n_iter\n",
    "    logger[method]['norm_thetas'] = norm_thetas\n",
    "    logger[method]['costs'] = costs                 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing variables..\n",
      "\n",
      "Running Gradient Descent..\n",
      "Converged in 1196 updates and 1196 epochs..\n",
      "\n",
      "Running Stochastic Gradient Descent..\n",
      "Converged in 1173 updates and 23 epochs..\n",
      "\n",
      "Running Momentum..\n",
      "Converged in 204 updates and 4 epochs..\n",
      "\n",
      "Running Nestrov Momentum..\n",
      "Converged in 255 updates and 5 epochs..\n",
      "\n",
      "Running Adagrad..\n",
      "Converged in 29250 updates and 29250 epochs..\n",
      "\n",
      "Running RMSProp..\n",
      "Converged in 1149 updates and 1149 epochs..\n",
      "\n",
      "Running Adam..\n",
      "Converged in 243 updates and 243 epochs..\n"
     ]
    }
   ],
   "source": [
    "methods = ['Gradient Descent','Stochastic Gradient Descent','Momentum','Nestrov Momentum','Adagrad','RMSProp','Adam']\n",
    "print('Initializing variables..')\n",
    "for method in methods:\n",
    "    run(X, Y, alpha, gamma, delta, eps, rho_s, rho_r, batch_size, logger, method=method)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1296x360 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1296x360 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "var = 'costs'\n",
    "plt.figure(figsize=(18,5))\n",
    "plt.subplot(141)\n",
    "plotting(logger, var, methods=['Gradient Descent'])\n",
    "plt.subplot(142)\n",
    "plotting(logger, var, methods=['Stochastic Gradient Descent', 'Momentum', 'Nestrov Momentum'])\n",
    "plt.subplot(143)\n",
    "plotting(logger, var, methods=['Adagrad'])\n",
    "plt.subplot(144)\n",
    "plotting(logger, var, methods=['RMSProp','Adam'])\n",
    "plt.show()\n",
    "\n",
    "var = 'norm_thetas'\n",
    "plt.figure(figsize=(18,5))\n",
    "plt.subplot(141)\n",
    "plotting(logger, var, methods=['Gradient Descent'])\n",
    "plt.subplot(142)\n",
    "plotting(logger, var, methods=['Stochastic Gradient Descent', 'Momentum', 'Nestrov Momentum'])\n",
    "plt.subplot(143)\n",
    "plotting(logger, var, methods=['Adagrad'])\n",
    "plt.subplot(144)\n",
    "plotting(logger, var, methods=['RMSProp','Adam'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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>optimizer</th>\n",
       "      <th>n_updates</th>\n",
       "      <th>n_epochs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Momentum</td>\n",
       "      <td>204</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Nestrov Momentum</td>\n",
       "      <td>255</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Stochastic Gradient Descent</td>\n",
       "      <td>1173</td>\n",
       "      <td>23</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Adam</td>\n",
       "      <td>243</td>\n",
       "      <td>243</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>RMSProp</td>\n",
       "      <td>1149</td>\n",
       "      <td>1149</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Gradient Descent</td>\n",
       "      <td>1196</td>\n",
       "      <td>1196</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Adagrad</td>\n",
       "      <td>29250</td>\n",
       "      <td>29250</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     optimizer n_updates n_epochs\n",
       "0                     Momentum       204        4\n",
       "1             Nestrov Momentum       255        5\n",
       "2  Stochastic Gradient Descent      1173       23\n",
       "3                         Adam       243      243\n",
       "4                      RMSProp      1149     1149\n",
       "5             Gradient Descent      1196     1196\n",
       "6                      Adagrad     29250    29250"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(columns=['optimizer','n_updates','n_epochs'])\n",
    "for idx, method in enumerate(logger.keys()):\n",
    "    df.loc[idx, 'optimizer'] = method\n",
    "    df.loc[idx, 'n_updates'] = logger[method]['n_updates']\n",
    "    df.loc[idx, 'n_epochs'] = len(logger[method]['costs'])\n",
    "\n",
    "df = df.sort_values(by='n_epochs').reset_index(drop=True)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "951daa5e1959839fcb325fff331f52e72634f7a1be998f6081ed7f433b63f1b3"
  },
  "kernelspec": {
   "display_name": "Python 3.8.11 64-bit ('base': conda)",
   "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.8.11"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}