Partially adaptive momentum estimation method (Padam).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-19T07:34:05.506232Z",
     "start_time": "2019-05-19T07:34:03.863205Z"
    }
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.python.eager import context\n",
    "from tensorflow.python.framework import ops\n",
    "from tensorflow.python.ops import control_flow_ops\n",
    "from tensorflow.python.ops import math_ops\n",
    "from tensorflow.python.ops import resource_variable_ops\n",
    "from tensorflow.python.ops import state_ops\n",
    "from tensorflow.python.ops import variable_scope\n",
    "from tensorflow.python.training import optimizer\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-19T07:34:05.546932Z",
     "start_time": "2019-05-19T07:34:05.508467Z"
    }
   },
   "outputs": [],
   "source": [
    "class PADAM(optimizer.Optimizer):\n",
    "    \"\"\"Implementation of PADAM\n",
    "    See https://arxiv.org/pdf/1806.06763v1.pdf\n",
    "    @@__init__\n",
    "    \"\"\"\n",
    "    def __init__(self, learning_rate=0.001, beta1=0.9, beta2=0.999, p=0.5, epsilon=1e-8, use_locking=False, name=\"PADAM\"):\n",
    "        super(PADAM, self).__init__(use_locking, name)\n",
    "        self._lr = learning_rate\n",
    "        self._beta1 = beta1\n",
    "        self._beta2 = beta2\n",
    "        self._p=p\n",
    "        self._epsilon=epsilon\n",
    "        \n",
    "        # Tensor versions of the constructor arguments, created in _prepare().\n",
    "        self._beta1_t = None\n",
    "        self._beta2_t = None\n",
    "        self._lr_t = None\n",
    "        self._epsilon_t = None\n",
    "        self._p_t=None\n",
    "        \n",
    "        self._beta1_power = None\n",
    "        self._beta2_power = None\n",
    "    \n",
    "    def _create_slots(self, var_list):\n",
    "        first_var = min(var_list, key=lambda x: x.name)\n",
    "\n",
    "        create_new = self._beta1_power is None\n",
    "        if not create_new and context.in_graph_mode():\n",
    "            create_new = (self._beta1_power.graph is not first_var.graph)\n",
    "\n",
    "        if create_new:\n",
    "            with ops.colocate_with(first_var):\n",
    "                self._beta1_power = variable_scope.variable(self._beta1, name=\"beta1_power\", trainable=False)\n",
    "                self._beta2_power = variable_scope.variable(self._beta2, name=\"beta2_power\", trainable=False)\n",
    "        # Create slots for the first and second moments.\n",
    "        for v in var_list:\n",
    "            self._zeros_slot(v, \"m\", self._name)\n",
    "            self._zeros_slot(v, \"v\", self._name)\n",
    "            self._zeros_slot(v, \"vhat\", self._name)\n",
    "\n",
    "    def _prepare(self):\n",
    "        self._lr_t = ops.convert_to_tensor(self._lr, name=\"lr\")\n",
    "        self._beta1_t = ops.convert_to_tensor(self._beta1, name=\"beta1\")\n",
    "        self._beta2_t = ops.convert_to_tensor(self._beta2, name=\"beta2\")\n",
    "        self._epsilon_t = ops.convert_to_tensor(self._epsilon, name=\"epsilon\")\n",
    "        self._p_t=ops.convert_to_tensor(self._p, name=\"p\")\n",
    "        \n",
    "    def _apply_dense(self, grad, var):\n",
    "        beta1_power = math_ops.cast(self._beta1_power, var.dtype.base_dtype)\n",
    "        beta2_power = math_ops.cast(self._beta2_power, var.dtype.base_dtype)\n",
    "        lr_t = math_ops.cast(self._lr_t, var.dtype.base_dtype)\n",
    "        beta1_t = math_ops.cast(self._beta1_t, var.dtype.base_dtype)\n",
    "        beta2_t = math_ops.cast(self._beta2_t, var.dtype.base_dtype)\n",
    "        epsilon_t = math_ops.cast(self._epsilon_t, var.dtype.base_dtype)\n",
    "        p_t=math_ops.cast(self._p_t, var.dtype.base_dtype)\n",
    "\n",
    "        lr = (lr_t * math_ops.sqrt(1 - beta2_power) / (1 - beta1_power))\n",
    "\n",
    "        # m_t = beta1 * m + (1 - beta1) * g_t\n",
    "        m = self.get_slot(var, \"m\")\n",
    "        m_scaled_g_values = grad * (1 - beta1_t)\n",
    "        m_t = state_ops.assign(m, beta1_t * m + m_scaled_g_values, use_locking=self._use_locking)\n",
    "\n",
    "        # v_t = beta2 * v + (1 - beta2) * (g_t * g_t)\n",
    "        v = self.get_slot(var, \"v\")\n",
    "        v_scaled_g_values = (grad * grad) * (1 - beta2_t)\n",
    "        v_t = state_ops.assign(v, beta2_t * v + v_scaled_g_values, use_locking=self._use_locking)\n",
    "\n",
    "        # padam\n",
    "        vhat = self.get_slot(var, \"vhat\")\n",
    "        vhat_t = state_ops.assign(vhat, math_ops.maximum(v_t, vhat))\n",
    "        v_partial = math_ops.pow(vhat_t, p_t)\n",
    "\n",
    "        var_update = state_ops.assign_sub(var, lr * m_t / (v_partial + epsilon_t), use_locking=self._use_locking)\n",
    "        return control_flow_ops.group(*[var_update, m_t, v_t, vhat_t])\n",
    "\n",
    "    def _resource_apply_dense(self, grad, var):\n",
    "        var = var.handle\n",
    "        beta1_power = math_ops.cast(self._beta1_power, grad.dtype.base_dtype)\n",
    "        beta2_power = math_ops.cast(self._beta2_power, grad.dtype.base_dtype)\n",
    "        lr_t = math_ops.cast(self._lr_t, grad.dtype.base_dtype)\n",
    "        beta1_t = math_ops.cast(self._beta1_t, grad.dtype.base_dtype)\n",
    "        beta2_t = math_ops.cast(self._beta2_t, grad.dtype.base_dtype)\n",
    "        epsilon_t = math_ops.cast(self._epsilon_t, grad.dtype.base_dtype)\n",
    "        p_t=math_ops.cast(self._p_t, var.dtype.base_dtype)\n",
    "\n",
    "        lr = (lr_t * math_ops.sqrt(1 - beta2_power) / (1 - beta1_power))\n",
    "\n",
    "        # m_t = beta1 * m + (1 - beta1) * g_t\n",
    "        m = self.get_slot(var, \"m\").handle\n",
    "        m_scaled_g_values = grad * (1 - beta1_t)\n",
    "        m_t = state_ops.assign(m, beta1_t * m + m_scaled_g_values, use_locking=self._use_locking)\n",
    "\n",
    "        # v_t = beta2 * v + (1 - beta2) * (g_t * g_t)\n",
    "        v = self.get_slot(var, \"v\").handle\n",
    "        v_scaled_g_values = (grad * grad) * (1 - beta2_t)\n",
    "        v_t = state_ops.assign(v, beta2_t * v + v_scaled_g_values, use_locking=self._use_locking)\n",
    "\n",
    "        # padam\n",
    "        vhat = self.get_slot(var, \"vhat\").handle\n",
    "        vhat_t = state_ops.assign(vhat, math_ops.maximum(v_t, vhat))\n",
    "        v_partial = math_ops.pow(vhat_t, p_t)\n",
    "\n",
    "        var_update = state_ops.assign_sub(var, lr * m_t / (v_partial + epsilon_t), use_locking=self._use_locking)\n",
    "        return control_flow_ops.group(*[var_update, m_t, v_t, vhat_t])\n",
    "\n",
    "    def _apply_sparse_shared(self, grad, var, indices, scatter_add):\n",
    "        beta1_power = math_ops.cast(self._beta1_power, var.dtype.base_dtype)\n",
    "        beta2_power = math_ops.cast(self._beta2_power, var.dtype.base_dtype)\n",
    "        lr_t = math_ops.cast(self._lr_t, var.dtype.base_dtype)\n",
    "        beta1_t = math_ops.cast(self._beta1_t, var.dtype.base_dtype)\n",
    "        beta2_t = math_ops.cast(self._beta2_t, var.dtype.base_dtype)\n",
    "        epsilon_t = math_ops.cast(self._epsilon_t, var.dtype.base_dtype)\n",
    "        p_t=math_ops.cast(self._p_t, var.dtype.base_dtype)\n",
    "\n",
    "        lr = (lr_t * math_ops.sqrt(1 - beta2_power) / (1 - beta1_power))\n",
    "\n",
    "        # m_t = beta1 * m + (1 - beta1) * g_t\n",
    "        m = self.get_slot(var, \"m\")\n",
    "        m_scaled_g_values = grad * (1 - beta1_t)\n",
    "        m_t = state_ops.assign(m, m * beta1_t, use_locking=self._use_locking)\n",
    "        with ops.control_dependencies([m_t]):\n",
    "            m_t = scatter_add(m, indices, m_scaled_g_values)\n",
    "\n",
    "        # v_t = beta2 * v + (1 - beta2) * (g_t * g_t)\n",
    "        v = self.get_slot(var, \"v\")\n",
    "        v_scaled_g_values = (grad * grad) * (1 - beta2_t)\n",
    "        v_t = state_ops.assign(v, v * beta2_t, use_locking=self._use_locking)\n",
    "        with ops.control_dependencies([v_t]):\n",
    "            v_t = scatter_add(v, indices, v_scaled_g_values)\n",
    "\n",
    "        # padam\n",
    "        vhat = self.get_slot(var, \"vhat\")\n",
    "        vhat_t = state_ops.assign(vhat, math_ops.maximum(v_t, vhat))\n",
    "        v_partial = math_ops.pow(vhat_t, p_t)\n",
    "        var_update = state_ops.assign_sub(var, lr * m_t / (v_partial + epsilon_t), use_locking=self._use_locking)\n",
    "        return control_flow_ops.group(*[var_update, m_t, v_t, vhat_t])\n",
    "\n",
    "    def _apply_sparse(self, grad, var):\n",
    "        return self._apply_sparse_shared(\n",
    "            grad.values,\n",
    "            var,\n",
    "            grad.indices,\n",
    "            lambda x, i, v: state_ops.\n",
    "            scatter_add(  # pylint: disable=g-long-lambda\n",
    "                x, i, v, use_locking=self._use_locking\n",
    "            )\n",
    "        )\n",
    "\n",
    "    def _resource_scatter_add(self, x, i, v):\n",
    "        with ops.control_dependencies([resource_variable_ops.resource_scatter_add(x.handle, i, v)]):\n",
    "            return x.value()\n",
    "\n",
    "    def _resource_apply_sparse(self, grad, var, indices):\n",
    "        return self._apply_sparse_shared(grad, var, indices, self._resource_scatter_add)\n",
    "\n",
    "    def _finish(self, update_ops, name_scope):\n",
    "        # Update the power accumulators.\n",
    "        with ops.control_dependencies(update_ops):\n",
    "            with ops.colocate_with(self._beta1_power):\n",
    "                update_beta1 = self._beta1_power.assign(\n",
    "                    self._beta1_power * self._beta1_t, use_locking=self._use_locking\n",
    "                )\n",
    "                update_beta2 = self._beta2_power.assign(\n",
    "                    self._beta2_power * self._beta2_t, use_locking=self._use_locking\n",
    "                )\n",
    "        return control_flow_ops.group(*update_ops + [update_beta1, update_beta2], name=name_scope)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing the performance of the optimizers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-19T07:34:05.745182Z",
     "start_time": "2019-05-19T07:34:05.549169Z"
    }
   },
   "outputs": [],
   "source": [
    "#Comparision between the optimizers\n",
    "def RosenbrockOpt(optimizer,MAX_EPOCHS = 4000, MAX_STEP = 100):\n",
    "    '''\n",
    "    returns distance of each step*MAX_STEP w.r.t minimum (1,1)\n",
    "    '''\n",
    "    x1_data = tf.Variable(initial_value=tf.random_uniform([1], minval=-3, maxval=3,seed=0),name='x1')\n",
    "    x2_data = tf.Variable(initial_value=tf.random_uniform([1], minval=-3, maxval=3,seed=1), name='x2')\n",
    "\n",
    "    y = tf.add(tf.pow(tf.subtract(1.0, x1_data), 2.0),\n",
    "    tf.multiply(100.0, tf.pow(tf.subtract(x2_data, tf.pow(x1_data, 2.0)), 2.0)), 'y')\n",
    "\n",
    "    global_step_tensor = tf.Variable(0, trainable=False, name='global_step')\n",
    "\n",
    "    train = optimizer.minimize(y,global_step=global_step_tensor)\n",
    "\n",
    "    sess = tf.Session()\n",
    "\n",
    "    init = tf.global_variables_initializer()#tf.initialize_all_variables()\n",
    "    sess.run(init)\n",
    "\n",
    "    minx = 1.0\n",
    "    miny = 1.0\n",
    "\n",
    "    distance = []\n",
    "    xx_ = sess.run(x1_data)\n",
    "    yy_ = sess.run(x2_data)\n",
    "#     print(0,xx_,yy_,np.sqrt((minx-xx_)**2+(miny-yy_)**2))\n",
    "    for step in range(MAX_EPOCHS):\n",
    "      _, xx_, yy_, zz_ = sess.run([train,x1_data,x2_data,y])\n",
    "      if step % MAX_STEP == 0:\n",
    "#          print(step+1, xx_,yy_, zz_)\n",
    "         distance += [ np.sqrt((minx-xx_)**2+(miny-yy_)**2)]\n",
    "    sess.close()\n",
    "    return distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-19T07:34:09.864292Z",
     "start_time": "2019-05-19T07:34:05.749972Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/sanket/.conda/envs/my_root/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot the convergence graphs\n",
    "plt.plot(RosenbrockOpt(PADAM(p=0.3)), color=\"red\")\n",
    "plt.plot(RosenbrockOpt(tf.train.AdamOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8)), color=\"green\")\n",
    "plt.plot(RosenbrockOpt(tf.train.AdagradOptimizer(learning_rate=0.001)), color=\"blue\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-19T07:34:27.159269Z",
     "start_time": "2019-05-19T07:34:09.866850Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot the convergence graph for different partial adaptive parameter\n",
    "for i in np.arange(0.1,0.6,0.05):\n",
    "    plt.plot(RosenbrockOpt(PADAM(p=i)), label=\"p=\"+str(i))\n",
    "plt.legend(bbox_to_anchor=(1.1, 1.05))\n",
    "plt.show()"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}