Tutorials/_Project_5_autograd_proto.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Operator Magic Method**\n",
    "\n",
    "```python\n",
    "Binary Operators:                Comparison Operators:        Assignment Operators:\n",
    "+   __add__(self, other)         <   __lt__(self, other)      -=   __isub__(self, other)\n",
    "–   __sub__(self, other)         >   __gt__(self, other)      +=   __iadd__(self, other)\n",
    "*   __mul__(self, other)         <=  __le__(self, other)      *=   __imul__(self, other)\n",
    "/   __truediv__(self, other)     >=  __ge__(self, other)      /=   __idiv__(self, other)\n",
    "//  __floordiv__(self, other)    ==  __eq__(self, other)      //=  __ifloordiv__(self, other)\n",
    "%   __mod__(self, other)         !=  __ne__(self, other)      %=   __imod__(self, other)\n",
    "**  __pow__(self, other)                                      **=  __ipow__(self, other)\n",
    ">>  __rshift__(self, other)                                   >>=  __irshift__(self, other)\n",
    "<<  __lshift__(self, other)      Unary Operators:             <<=  __ilshift__(self, other)\n",
    "&   __and__(self, other)         –   __neg__(self)            &=   __iand__(self, other)\n",
    "|   __or__(self, other)          +   __pos__(self)            |=   __ior__(self, other)\n",
    "^   __xor__(self, other)         ~   __invert__(self)         ^=   __ixor__(self, other)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "class Tensor:\n",
    "    def __init__(self, val, requires_grad=False, grad_fn=None, depends_on=[]):\n",
    "        self.val = val\n",
    "        self.requires_grad = requires_grad\n",
    "        self.grad_fn = grad_fn\n",
    "        self.depends_on = depends_on\n",
    "        self.grad = 0\n",
    "    \n",
    "    def backward(self, grad=1):\n",
    "        self.grad += grad\n",
    "        \n",
    "        for tensor, cache in self.depends_on:\n",
    "            _grad = self.grad_fn(grad, tensor, cache)\n",
    "            tensor.backward(_grad)\n",
    "    \n",
    "    # for +, python invoke the front object's __add__ in default\n",
    "    def __add__(self, other):\n",
    "        assert isinstance(other, (Tensor, int, float)), f\"Unsupported Add between Tensor and {type(other)}.\"\n",
    "        \n",
    "        depends_on = []\n",
    "        grad_fn = AddBackward\n",
    "        requires_grad = self.requires_grad\n",
    "        if self.requires_grad:\n",
    "            depends_on.append((self, []))\n",
    "            \n",
    "        if isinstance(other, Tensor):\n",
    "            val = self.val + other.val\n",
    "            requires_grad = requires_grad or other.requires_grad\n",
    "            if other.requires_grad:\n",
    "                depends_on.append((other, []))\n",
    "        else:\n",
    "            val = self.val + other\n",
    "        \n",
    "        return Tensor(val, requires_grad, grad_fn, depends_on)\n",
    "    \n",
    "    # if the front object's __add__ is not supported for this +, then python invoke second object's __radd__\n",
    "    def __radd__(self, other):\n",
    "        return self.__add__(other)\n",
    "    \n",
    "    def __sub__(self, other):\n",
    "        assert isinstance(other, (Tensor, int, float)), f\"Unsupported Sub between Tensor and {type(other)}.\"\n",
    "        \n",
    "        depends_on = []\n",
    "        grad_fn = SubBackward\n",
    "        requires_grad = self.requires_grad\n",
    "        \n",
    "        if self.requires_grad:\n",
    "            depends_on.append((self, [1])) # 1 indicates left val\n",
    "        \n",
    "        if isinstance(other, Tensor):\n",
    "            val = self.val - other.val\n",
    "            requires_grad = requires_grad or other.requires_grad\n",
    "            if other.requires_grad:\n",
    "                depends_on.append((other, [-1])) # -1 indicates right val\n",
    "        else:\n",
    "            val = self.val - other\n",
    "        \n",
    "        return Tensor(val, requires_grad, grad_fn, depends_on)\n",
    "    \n",
    "    def __rsub__(self, other):\n",
    "        \"\"\"Do not just use unary minus for avoiding adding a new tensor in backward chain\"\"\"\n",
    "        assert isinstance(other, (int, float)), f\"Unsupported Sub between {type(other)} and Tensor.\"\n",
    "        \n",
    "        depends_on = []\n",
    "        grad_fn = SubBackward\n",
    "        requires_grad = self.requires_grad\n",
    "        \n",
    "        val = other - self.val\n",
    "        if self.requires_grad:\n",
    "            depends_on.append((self, [-1])) # -1 indicates right val\n",
    "        \n",
    "        return Tensor(val, requires_grad, grad_fn, depends_on)\n",
    "    \n",
    "    def __mul__(self, other):\n",
    "        assert isinstance(other, (Tensor, int, float)), f\"Unsupported Mul between Tensor and {type(other)}.\"\n",
    "        \n",
    "        depends_on = []\n",
    "        grad_fn = MulBackward\n",
    "        requires_grad = self.requires_grad\n",
    "        \n",
    "        if isinstance(other, Tensor):\n",
    "            val = self.val * other.val\n",
    "            requires_grad = requires_grad or other.requires_grad\n",
    "            if self.requires_grad:\n",
    "                depends_on.append((self, [other.val]))\n",
    "            \n",
    "            if other.requires_grad:\n",
    "                depends_on.append((other, [self.val]))\n",
    "        else:\n",
    "            val = self.val * other\n",
    "            if self.requires_grad:\n",
    "                depends_on.append((self, [other])) # cache another value for derivative\n",
    "        \n",
    "        return Tensor(val, requires_grad, grad_fn, depends_on)\n",
    "    \n",
    "    def __rmul__(self, other):\n",
    "        return self.__mul__(other)\n",
    "    \n",
    "    def __pow__(self, power):\n",
    "        assert isinstance(power, (int, float)), f\"Unsupported Pow between Tensor and {type(other)}.\"\n",
    "        \n",
    "        depends_on = []\n",
    "        grad_fn = PowBackward\n",
    "        requires_grad = self.requires_grad\n",
    "        \n",
    "        val = np.power(self.val, power)\n",
    "        if self.requires_grad:\n",
    "            depends_on.append((self, [power]))\n",
    "            \n",
    "        return Tensor(val, requires_grad, grad_fn, depends_on)\n",
    "    \n",
    "    def __neg__(self):\n",
    "        depends_on = []\n",
    "        grad_fn = NegBackward\n",
    "        requires_grad = self.requires_grad\n",
    "        \n",
    "        val = -self.val\n",
    "        if self.requires_grad:\n",
    "            depends_on.append((self, [-1]))\n",
    "        \n",
    "        return Tensor(val, requires_grad, grad_fn, depends_on)\n",
    "    \n",
    "    def exp(self):        \n",
    "        depends_on = []\n",
    "        grad_fn = ExpBackward\n",
    "        requires_grad = self.requires_grad\n",
    "        \n",
    "        val = np.exp(self.val)\n",
    "        if self.requires_grad:\n",
    "            depends_on.append((self, [val]))\n",
    "            \n",
    "        return Tensor(val, requires_grad, grad_fn, depends_on)\n",
    "    \n",
    "    def __lt__(self, other):\n",
    "        assert isinstance(other, (Tensor, int, float)), f\"Unsupported '<' between Tensor and {type(other)}.\"\n",
    "        \n",
    "        return self.val < (other.val if isinstance(other, Tensor) else other)\n",
    "    \n",
    "    def __gt__(self, other):\n",
    "        assert isinstance(other, (Tensor, int, float)), f\"Unsupported '>' between Tensor and {type(other)}.\"\n",
    "        \n",
    "        return self.val > (other.val if isinstance(other, Tensor) else other)\n",
    "    \n",
    "def AddBackward(grad, tensor, cache):\n",
    "    return grad * np.ones_like(tensor.val)\n",
    "\n",
    "def SubBackward(grad, tensor, cache):\n",
    "    \"\"\"grad * cache[0] == grad * np.ones_like(tensor.val) * cache[0]\"\"\"\n",
    "    return grad * np.ones_like(tensor.val) * cache[0]\n",
    "\n",
    "def MulBackward(grad, tensor, cache):\n",
    "    return grad * cache[0]\n",
    "\n",
    "def PowBackward(grad, tensor, cache):\n",
    "    power = cache[0]\n",
    "    return grad * power * np.power(tensor.val, power-1)\n",
    "\n",
    "def NegBackward(grad, tensor, cache):\n",
    "    \"\"\"grad * cache[0] == grad * np.ones_like(tensor.val) * cache[0]\"\"\"\n",
    "    return grad * np.ones_like(tensor.val) * cache[0]\n",
    "\n",
    "def ExpBackward(grad, tensor, cache):\n",
    "    \"\"\"cache[0] == np.exp(tensor.val)\"\"\"\n",
    "    return grad * cache[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Helper Function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot(x, y=[], title=None):\n",
    "    if title:\n",
    "        plt.title(title) \n",
    "    if y:\n",
    "        for line in y:\n",
    "            plt.plot(x, line[0], label=line[1])\n",
    "    else:\n",
    "        plt.plot(x)\n",
    "    plt.grid(True)\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Draw Ricker Wavelet Function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "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": [
    "# Params\n",
    "f = 3\n",
    "pi = 3.14\n",
    "precision = 500\n",
    "# Domain\n",
    "t = np.linspace(-1, 1, precision)\n",
    "\n",
    "# Ricker wavelet function\n",
    "ricker = (1-2*(pi*f*t)**2)*np.exp(-(pi*f*t)**2)\n",
    "\n",
    "# Ricker wavelet function with autograd, which should be the same as above function\n",
    "v_t = Tensor(t, requires_grad=True)\n",
    "v_ricker = (1-2*(pi*f*v_t)**2)*(-(pi*f*v_t)**2).exp()\n",
    "v_ricker.backward() # get first derivative\n",
    "\n",
    "plot(t, [(ricker, 'Ricker wavelet'), (v_ricker.val, 'Tensor Ricker')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Plot 3 types of derivatives**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "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": [
    "# numerical differentiation\n",
    "delta_t = t[1]-t[0]\n",
    "nd_ricker = np.zeros(precision)\n",
    "nd_ricker[1:-1] = (ricker[2::]-ricker[0:-2])/(2*delta_t)\n",
    "\n",
    "# symbolic derivation\n",
    "sd_ricker = 2*f**2*pi**2*t*(2*f**2*pi**2*t**2-3)*np.exp(-f**2*pi**2*t**2)\n",
    "\n",
    "# autograd\n",
    "autograd = v_t.grad\n",
    "\n",
    "# all above should be approximately the same, but numerical derivative would cause a little error\n",
    "plot(t,[(nd_ricker, 'numerical'), (sd_ricker, 'symbolic'), (autograd, 'autograd')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Compare symbolic (accurate value) with the other two**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "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(t, [(nd_ricker-sd_ricker, 'symbolic-numerical'), (v_t.grad-sd_ricker, 'symbolic-autograd')])"
   ]
  }
 ],
 "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.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}