tutorials/Automatic Differentiation for nonlinear operators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bdad36b5",
   "metadata": {},
   "source": [
    "# Automatic Differentiation for nonlinear operators\n",
    "\n",
    "@Author: Francesco Picetti - picettifrancesco@gmail.com\n",
    "\n",
    "In this notebook, we build a new kind of operator that leverages a new entry in the PyTorch ecosystem, [functorch](https://pytorch.org/functorch/stable/). Basically, it allows for the computation of the Jacobian-vector product given a function defined with PyTorch primitives."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cee6a27f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING! DATAPATH not found. The folder /tmp will be used to write binary files\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nas/home/fpicetti/miniconda3/envs/occd/lib/python3.10/site-packages/dask_jobqueue/core.py:20: FutureWarning: tmpfile is deprecated and will be removed in a future release. Please use dask.utils.tmpfile instead.\n",
      "  from distributed.utils import tmpfile\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import occamypy as o\n",
    "\n",
    "o.backend.set_seed_everywhere()\n",
    "\n",
    "try:\n",
    "    from functorch import jvp\n",
    "except ModuleNotFoundError:\n",
    "    raise ModuleNotFoundError(\"This submodule requires functorch to be installed. Do it with:\\n\\tpip install functorch\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "652309c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class OperatorAD(o.Operator):\n",
    "\n",
    "    def __init__(self, domain: o.VectorTorch, range: o.VectorTorch, fwd_fn, background: o.VectorTorch = None, name: str = None):\n",
    "        \"\"\"\n",
    "        Generic operator whose forward is defined, and adjoint is computed with automatic differentiation\n",
    "        \n",
    "        Args:\n",
    "            domain: operator domain vector\n",
    "            range: operator range vector\n",
    "            fwd_fn: torch-compatible forward function\n",
    "            background: vector in which the Jacobian will be computed\n",
    "            name: function name for print purpose\n",
    "        \"\"\"\n",
    "        self.fwd_fn = fwd_fn\n",
    "        \n",
    "        # store the vector to be multiplied with the Jacobian\n",
    "        self.domain_tensor = torch.ones_like(domain[:])\n",
    "        # store the domain vector in which the function will be linearized\n",
    "        self.background = background if background is not None else domain\n",
    "\n",
    "        super(OperatorAD, self).__init__(domain=domain, range=range)\n",
    "        self.name = \"OperatorAD\" if name is None else name\n",
    "        \n",
    "    def forward(self, add, model, data):\n",
    "        self.checkDomainRange(model, data)\n",
    "        \n",
    "        if not add:\n",
    "            data.zero()\n",
    "        data[:] += self.fwd_fn(model[:])\n",
    "        return\n",
    "    \n",
    "    def adjoint(self, add, model, data):\n",
    "        self.checkDomainRange(model, data)\n",
    "\n",
    "        grad = jvp(self.fwd_fn, (self.background[:],), (self.domain_tensor,))[1]\n",
    "        \n",
    "        if not add:\n",
    "            model.zero()\n",
    "        model[:] += grad * data[:]\n",
    "        return\n",
    "    \n",
    "    def set_background(self, in_content: o.VectorTorch):\n",
    "        \"\"\"\n",
    "        Set the background vector in which the Jacobian will be computed\n",
    "\n",
    "        Args:\n",
    "            in_content: background vector\n",
    "        \"\"\"\n",
    "        self.background.copy(in_content)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00ff646a",
   "metadata": {},
   "source": [
    "## Case 1: linear function $f(x)=x$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "41c46527",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = tensor([1., 2., 3.])\n"
     ]
    }
   ],
   "source": [
    "x = o.VectorTorch(torch.tensor([1., 2., 3.]))\n",
    "print(\"x =\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09574a9d",
   "metadata": {},
   "source": [
    "Forward function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8085472d",
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a8f2c71",
   "metadata": {},
   "source": [
    "Analytical gradient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e2675b76",
   "metadata": {},
   "outputs": [],
   "source": [
    "g = lambda x: 1."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5659c61",
   "metadata": {},
   "source": [
    "Instantiate the operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ed83d738",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A is x\n"
     ]
    }
   ],
   "source": [
    "A = OperatorAD(domain=x, range=x, fwd_fn=f, name=\"x\")\n",
    "print(\"A is %s\" % A.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82caf0fc",
   "metadata": {},
   "source": [
    "Forward computation: $\\mathbf{y}=f(\\mathbf{x}) = \\mathbf{A} \\mathbf{x}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "21dd5e53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = f(x) = tensor([1., 2., 3.])\n"
     ]
    }
   ],
   "source": [
    "y = A * x\n",
    "assert torch.allclose(y[:], f(x[:]))\n",
    "print(\"y = f(x) =\", y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10066597",
   "metadata": {},
   "source": [
    "Adjoint computation: $\\mathbf{z} = \\frac{\\partial f}{\\partial \\mathbf{x}}\\Bigr|_{\\mathbf{x}=\\mathbf{x}_0}  \\mathbf{y}$\n",
    "\n",
    "1. set the linearization domain where the gradient is computed (default is the domain vector passed to the `__init__`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9e2ccb59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The gradient ∂f/∂x will be computed at x0 = tensor([1., 2., 3.])\n"
     ]
    }
   ],
   "source": [
    "A.set_background(x)\n",
    "print(\"The gradient ∂f/∂x will be computed at x0 =\", A.background)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1f43e1e",
   "metadata": {},
   "source": [
    "2. compute the gradient and multiply it with data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9efb9a90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z = ∂f/∂x0 * y = tensor([1., 2., 3.])\n"
     ]
    }
   ],
   "source": [
    "z = A.H * y\n",
    "assert torch.allclose(z[:], g(A.background[:]) * y[:])\n",
    "print(\"z = ∂f/∂x0 * y =\", z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b98d35b6",
   "metadata": {},
   "source": [
    "Let's use another linearization point $\\mathbf{x}_0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "136b8ba1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The gradient ∂f/∂x0 will be computed on x0 = tensor([-0.0075,  0.5364, -0.8230])\n"
     ]
    }
   ],
   "source": [
    "x0 = x.clone().rand()\n",
    "A.set_background(x0)\n",
    "print(\"The gradient ∂f/∂x0 will be computed on x0 =\", A.background)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e6fde0d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z = ∂f/∂x0 * y = tensor([1., 2., 3.])\n"
     ]
    }
   ],
   "source": [
    "z = A.H * y\n",
    "assert torch.allclose(z[:], g(A.background[:]) * y[:])\n",
    "print(\"z = ∂f/∂x0 * y =\", z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "932b43f1",
   "metadata": {},
   "source": [
    "As $f(x)=x$ is linear, we can compute the dot product test for operator $\\mathbf{A}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3c636d69",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dot-product tests of forward and adjoint operators\n",
      "--------------------------------------------------\n",
      "Applying forward operator add=False\n",
      " Runs in: 0.00019025802612304688 seconds\n",
      "Applying adjoint operator add=False\n",
      " Runs in: 0.0007958412170410156 seconds\n",
      "Dot products add=False: domain=3.146009e-01 range=3.146009e-01 \n",
      "Absolute error: 0.000000e+00\n",
      "Relative error: 0.000000e+00 \n",
      "\n",
      "Applying forward operator add=True\n",
      " Runs in: 3.981590270996094e-05 seconds\n",
      "Applying adjoint operator add=True\n",
      " Runs in: 0.0004761219024658203 seconds\n",
      "Dot products add=True: domain=6.292018e-01 range=6.292018e-01 \n",
      "Absolute error: 0.000000e+00\n",
      "Relative error: 0.000000e+00 \n",
      "\n",
      "-------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "A.dotTest(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e982386a",
   "metadata": {},
   "source": [
    "## Case 2: nonlinear function $f(x) = x \\sin(x)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4c111188",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = tensor([1., 2., 3.])\n"
     ]
    }
   ],
   "source": [
    "x = o.VectorTorch(torch.tensor([1., 2., 3.]))\n",
    "print(\"x =\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04487c43",
   "metadata": {},
   "source": [
    "Forward function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "90e688cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: x * torch.sin(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a430a09b",
   "metadata": {},
   "source": [
    "Analytical gradient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6f9dee61",
   "metadata": {},
   "outputs": [],
   "source": [
    "g = lambda x: x * torch.cos(x) + torch.sin(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4906c61",
   "metadata": {},
   "source": [
    "Instantiate the operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "214b3098",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A is x sin(x)\n"
     ]
    }
   ],
   "source": [
    "A = OperatorAD(domain=x, range=x, fwd_fn=f, name=\"x sin(x)\")\n",
    "print(\"A is %s\" % A.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fb36e70",
   "metadata": {},
   "source": [
    "Forward computation: $\\mathbf{y}=f(\\mathbf{x}) = \\mathbf{A} \\cdot \\mathbf{x}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4df2f8a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = f(x) = tensor([0.8415, 1.8186, 0.4234])\n"
     ]
    }
   ],
   "source": [
    " y = A * x\n",
    "assert torch.allclose(y[:], f(x[:]))\n",
    "print(\"y = f(x) =\", y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a31cc90c",
   "metadata": {},
   "source": [
    "Adjoint computation: $\\mathbf{z} = \\frac{\\partial f}{\\partial \\mathbf{x}}\\Bigr|_{\\mathbf{x}=\\mathbf{x}_0} \\cdot \\mathbf{y}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a0522d53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The gradient ∂f/∂x0 will be computed on x0 = tensor([1., 2., 3.])\n"
     ]
    }
   ],
   "source": [
    "print(\"The gradient ∂f/∂x0 will be computed on x0 =\", A.background)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6e9cc424",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z = ∂f1/∂x0 * y = tensor([ 1.1627,  0.1400, -1.1976])\n"
     ]
    }
   ],
   "source": [
    "z = A.H * y\n",
    "assert torch.allclose(z[:], g(A.background[:]) * y[:])\n",
    "print(\"z = ∂f1/∂x0 * y =\", z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88f95798",
   "metadata": {},
   "source": [
    "Let's use another linearization point $\\mathbf{x}_0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6fc284ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The gradient ∂f/∂x0 will be computed on x0 = tensor([ 0.6472,  0.2490, -0.3354])\n"
     ]
    }
   ],
   "source": [
    "x0 = x.clone().randn()\n",
    "A.set_background(x0)\n",
    "print(\"The gradient ∂f/∂x0 will be computed on x0 =\", A.background)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a1f0fd31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z = ∂f/∂x0 * y = tensor([ 0.9419,  0.8870, -0.2734])\n"
     ]
    }
   ],
   "source": [
    "z = A.H * y\n",
    "assert torch.allclose(z[:], g(A.background[:]) * y[:])\n",
    "print(\"z = ∂f/∂x0 * y =\", z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4ffb659",
   "metadata": {},
   "source": [
    "Finally, we can wrap $\\mathbf{A}$ into a `NonlinearOperator` and compute the linearization test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "18061880",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "B = o.NonlinearOperator(A)\n",
    "_, _ = B.linTest(x, plot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51a6876f",
   "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}