PINNs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "859935db-7a17-4683-9850-9b5554f7cc5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Callable\n",
    "import argparse\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.func import functional_call, grad, vmap\n",
    "import numpy as np\n",
    "import torchopt\n",
    "\n",
    "from collections import OrderedDict\n",
    "from typing import Callable\n",
    "\n",
    "R = 1.0  # rate of maximum population growth parameterizing the equation\n",
    "X_BOUNDARY = 0.0  # boundary condition coordinate\n",
    "F_BOUNDARY = 0.5  # boundary condition value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "963e7618-350b-4454-b627-f90285701282",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinearNN(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        num_inputs: int = 1,\n",
    "        num_layers: int = 1,\n",
    "        num_neurons: int = 5,\n",
    "        act: nn.Module = nn.Tanh(),\n",
    "    ) -> None:\n",
    "        \"\"\"Basic neural network architecture with linear layers\n",
    "        \n",
    "        Args:\n",
    "            num_inputs (int, optional): the dimensionality of the input tensor\n",
    "            num_layers (int, optional): the number of hidden layers\n",
    "            num_neurons (int, optional): the number of neurons for each hidden layer\n",
    "            act (nn.Module, optional): the non-linear activation function to use for stitching\n",
    "                linear layers togeter\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "        \n",
    "        self.num_inputs = num_inputs\n",
    "        self.num_neurons = num_neurons\n",
    "        self.num_layers = num_layers\n",
    "\n",
    "        layers = []\n",
    "\n",
    "        # input layer\n",
    "        layers.append(nn.Linear(self.num_inputs, num_neurons))\n",
    "\n",
    "        # hidden layers with linear layer and activation\n",
    "        for _ in range(num_layers):\n",
    "            layers.extend([nn.Linear(num_neurons, num_neurons), act])\n",
    "\n",
    "        # output layer\n",
    "        layers.append(nn.Linear(num_neurons, 1))\n",
    "\n",
    "        # build the network\n",
    "        self.network = nn.Sequential(*layers)\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        return self.network(x.reshape(-1, 1)).squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c0a35d2e-bb29-4585-bf85-33b8151e2b84",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_forward_fn(\n",
    "    model: nn.Module,\n",
    "    derivative_order: int = 1,\n",
    ") -> list[Callable]:\n",
    "    \"\"\"Make a functional forward pass and gradient functions given an input model\n",
    "\n",
    "    This function creates a set of functional calls of the input model\n",
    "\n",
    "    It returns a list of composable v-mapped version of the forward pass\n",
    "    and of higher-order derivatives with respect to the inputs as\n",
    "    specified by the input argument `derivative_order`\n",
    "\n",
    "    Args:\n",
    "        model (nn.Module): the model to make the functional calls for. It can be any subclass of\n",
    "            a nn.Module\n",
    "        derivative_order (int, optional): Up to which order return functions for computing the\n",
    "            derivative of the model with respect to the inputs\n",
    "\n",
    "    Returns:\n",
    "        list[Callable]: A list of functions where each element corresponds to\n",
    "            a v-mapped version of the model forward pass and its derivatives. The\n",
    "            0-th element is always the forward pass and, depending on the value of\n",
    "            the `derivative_order` argument, the following elements corresponds to\n",
    "            the i-th order derivative function with respect to the model inputs. The\n",
    "            vmap ensures efficient support for batched inputs\n",
    "    \"\"\"\n",
    "    # notice that `functional_call` supports batched input by default\n",
    "    # thus there is not need to call vmap on it, as it's instead the case\n",
    "    # for the derivative calls\n",
    "    def f(x: torch.Tensor, params: dict[str, torch.nn.Parameter] | tuple[torch.nn.Parameter, ...]) -> torch.Tensor:\n",
    "        \n",
    "        # the functional optimizer works with parameters represented as a tuple instead\n",
    "        # of the dictionary form required by the `functional_call` API \n",
    "        # here we perform the conversion from tuple to dictionary\n",
    "        if isinstance(params, tuple):\n",
    "            params_dict = tuple_to_dict_parameters(model, params)\n",
    "        else:\n",
    "            params_dict = params\n",
    "\n",
    "        return functional_call(model, params_dict, (x, ))\n",
    "\n",
    "    fns = []\n",
    "    fns.append(f)\n",
    "\n",
    "    dfunc = f\n",
    "    for _ in range(derivative_order):\n",
    "\n",
    "        # first compute the derivative function\n",
    "        dfunc = grad(dfunc)\n",
    "\n",
    "        # then use vmap to support batching\n",
    "        dfunc_vmap = vmap(dfunc, in_dims=(0, None))\n",
    "\n",
    "        fns.append(dfunc_vmap)\n",
    "\n",
    "    return fns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "3543b5d4-1d60-4788-84b9-6a6c04b211d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def tuple_to_dict_parameters(\n",
    "        model: nn.Module, params: tuple[torch.nn.Parameter, ...]\n",
    ") -> OrderedDict[str, torch.nn.Parameter]:\n",
    "    \"\"\"Convert a set of parameters stored as a tuple into a dictionary form\n",
    "\n",
    "    This conversion is required to be able to call the `functional_call` API which requires\n",
    "    parameters in a dictionary form from the results of a functional optimization step which \n",
    "    returns the parameters as a tuple\n",
    "\n",
    "    Args:\n",
    "        model (nn.Module): the model to make the functional calls for. It can be any subclass of\n",
    "            a nn.Module\n",
    "        params (tuple[Parameter, ...]): the model parameters stored as a tuple\n",
    "    \n",
    "    Returns:\n",
    "        An OrderedDict instance with the parameters stored as an ordered dictionary\n",
    "    \"\"\"\n",
    "    keys = list(dict(model.named_parameters()).keys())\n",
    "    values = list(params)\n",
    "    return OrderedDict(({k:v for k,v in zip(keys, values)}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b0e00eb8-fa16-44e6-9e6f-5588d3690ef7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_loss_fn(f: Callable, dfdx: Callable) -> Callable:\n",
    "    \"\"\"Make a function loss evaluation function\n",
    "\n",
    "    The loss is computed as sum of the interior MSE loss (the differential equation residual)\n",
    "    and the MSE of the loss at the boundary\n",
    "\n",
    "    Args:\n",
    "        f (Callable): The functional forward pass of the model used a universal function approximator. This\n",
    "            is a function with signature (x, params) where `x` is the input data and `params` the model\n",
    "            parameters\n",
    "        dfdx (Callable): The functional gradient calculation of the universal function approximator. This\n",
    "            is a function with signature (x, params) where `x` is the input data and `params` the model\n",
    "            parameters\n",
    "\n",
    "    Returns:\n",
    "        Callable: The loss function with signature (params, x) where `x` is the input data and `params` the model\n",
    "            parameters. Notice that a simple call to `dloss = functorch.grad(loss_fn)` would give the gradient\n",
    "            of the loss with respect to the model parameters needed by the optimizers\n",
    "    \"\"\"\n",
    "\n",
    "    def loss_fn(params: torch.Tensor, x: torch.Tensor):\n",
    "\n",
    "        # interior loss\n",
    "        f_value = f(x, params)\n",
    "        interior = dfdx(x, params) - R * f_value * (1 - f_value)\n",
    "\n",
    "        # boundary loss\n",
    "        x0 = X_BOUNDARY\n",
    "        f0 = F_BOUNDARY\n",
    "        x_boundary = torch.tensor([x0])\n",
    "        f_boundary = torch.tensor([f0])\n",
    "        boundary = f(x_boundary, params) - f_boundary\n",
    "\n",
    "        loss = nn.MSELoss()\n",
    "        loss_value = loss(interior, torch.zeros_like(interior)) + loss(\n",
    "            boundary, torch.zeros_like(boundary)\n",
    "        )\n",
    "\n",
    "        return loss_value\n",
    "\n",
    "    return loss_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "1eb20e8f-20aa-47b4-bc10-b82f62ca0213",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = LinearNN(num_layers=2)\n",
    "fns = make_forward_fn(model, derivative_order=2)\n",
    "\n",
    "batch_size = 10\n",
    "x = torch.randn(batch_size)\n",
    "# params = dict(model.named_parameters())\n",
    "params = dict(model.named_parameters())\n",
    "\n",
    "fn_x = fns[0](x, params)\n",
    "assert fn_x.shape[0] == batch_size\n",
    "\n",
    "dfn_x = fns[1](x, params)\n",
    "assert dfn_x.shape[0] == batch_size\n",
    "\n",
    "ddfn_x = fns[2](x, params)\n",
    "assert ddfn_x.shape[0] == batch_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2b2310c5-6ae2-4c50-ad3e-3414e0fedcab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 0 with loss 0.6875214576721191\n",
      "Iteration 1 with loss 0.07539822161197662\n",
      "Iteration 2 with loss 0.061332348734140396\n",
      "Iteration 3 with loss 0.06273967027664185\n",
      "Iteration 4 with loss 0.06033685430884361\n",
      "Iteration 5 with loss 0.06283890455961227\n",
      "Iteration 6 with loss 0.061326973140239716\n",
      "Iteration 7 with loss 0.055478230118751526\n",
      "Iteration 8 with loss 0.05606400594115257\n",
      "Iteration 9 with loss 0.04689626395702362\n",
      "Iteration 10 with loss 0.03450148552656174\n",
      "Iteration 11 with loss 0.02301076427102089\n",
      "Iteration 12 with loss 0.01398439984768629\n",
      "Iteration 13 with loss 0.04004715383052826\n",
      "Iteration 14 with loss 0.0183175690472126\n",
      "Iteration 15 with loss 0.011284571141004562\n",
      "Iteration 16 with loss 0.022073907777667046\n",
      "Iteration 17 with loss 0.029716994613409042\n",
      "Iteration 18 with loss 0.0209549181163311\n",
      "Iteration 19 with loss 0.01573590561747551\n",
      "Iteration 20 with loss 0.013831190764904022\n",
      "Iteration 21 with loss 0.006837528198957443\n",
      "Iteration 22 with loss 0.013024261221289635\n",
      "Iteration 23 with loss 0.015599042177200317\n",
      "Iteration 24 with loss 0.0032003293745219707\n",
      "Iteration 25 with loss 0.007893403992056847\n",
      "Iteration 26 with loss 0.014230833388864994\n",
      "Iteration 27 with loss 0.013726537115871906\n",
      "Iteration 28 with loss 0.009232064709067345\n",
      "Iteration 29 with loss 0.008101465180516243\n",
      "Iteration 30 with loss 0.003186636371538043\n",
      "Iteration 31 with loss 0.00312789436429739\n",
      "Iteration 32 with loss 0.004407254979014397\n",
      "Iteration 33 with loss 0.006560406181961298\n",
      "Iteration 34 with loss 0.008410368114709854\n",
      "Iteration 35 with loss 0.005242496263235807\n",
      "Iteration 36 with loss 0.005719812586903572\n",
      "Iteration 37 with loss 0.003596794791519642\n",
      "Iteration 38 with loss 0.002283877693116665\n",
      "Iteration 39 with loss 0.004649448674172163\n",
      "Iteration 40 with loss 0.002776081208139658\n",
      "Iteration 41 with loss 0.0010910205310210586\n",
      "Iteration 42 with loss 0.0026094000786542892\n",
      "Iteration 43 with loss 0.004686196334660053\n",
      "Iteration 44 with loss 0.0013478165492415428\n",
      "Iteration 45 with loss 0.000986261758953333\n",
      "Iteration 46 with loss 0.001633455976843834\n",
      "Iteration 47 with loss 0.0023679493460804224\n",
      "Iteration 48 with loss 0.0013480903580784798\n",
      "Iteration 49 with loss 0.0008805727702565491\n",
      "Iteration 50 with loss 0.0011787229450419545\n",
      "Iteration 51 with loss 0.0009815931553021073\n",
      "Iteration 52 with loss 0.0008029865566641092\n",
      "Iteration 53 with loss 0.0011906936997547746\n",
      "Iteration 54 with loss 0.000862645567394793\n",
      "Iteration 55 with loss 0.0006226323312148452\n",
      "Iteration 56 with loss 0.0003678811772260815\n",
      "Iteration 57 with loss 0.0003967579687014222\n",
      "Iteration 58 with loss 0.00047256951802410185\n",
      "Iteration 59 with loss 0.00047042546793818474\n",
      "Iteration 60 with loss 0.0002909601607825607\n",
      "Iteration 61 with loss 0.00039417759398929775\n",
      "Iteration 62 with loss 0.0004952377639710903\n",
      "Iteration 63 with loss 0.0008314332226291299\n",
      "Iteration 64 with loss 0.00041904105455614626\n",
      "Iteration 65 with loss 0.0003162287175655365\n",
      "Iteration 66 with loss 0.00019851695105899125\n",
      "Iteration 67 with loss 0.00023119995603337884\n",
      "Iteration 68 with loss 0.0003142615023534745\n",
      "Iteration 69 with loss 0.0002530221827328205\n",
      "Iteration 70 with loss 0.0003350639599375427\n",
      "Iteration 71 with loss 0.0002756809117272496\n",
      "Iteration 72 with loss 0.0004138315562158823\n",
      "Iteration 73 with loss 0.00016296344983857125\n",
      "Iteration 74 with loss 0.00023621812579222023\n",
      "Iteration 75 with loss 0.00013255089288577437\n",
      "Iteration 76 with loss 0.00012172273272881284\n",
      "Iteration 77 with loss 0.00018852345237974077\n",
      "Iteration 78 with loss 0.0001490691938670352\n",
      "Iteration 79 with loss 9.737285290611908e-05\n",
      "Iteration 80 with loss 7.646105950698256e-05\n",
      "Iteration 81 with loss 7.768684736220166e-05\n",
      "Iteration 82 with loss 9.187343675876036e-05\n",
      "Iteration 83 with loss 8.231985702877864e-05\n",
      "Iteration 84 with loss 6.577915337402374e-05\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 85 with loss 8.742924546822906e-05\n",
      "Iteration 86 with loss 9.389937622472644e-05\n",
      "Iteration 87 with loss 7.747642666799948e-05\n",
      "Iteration 88 with loss 8.164603059412912e-05\n",
      "Iteration 89 with loss 9.650236461311579e-05\n",
      "Iteration 90 with loss 2.3581842469866388e-05\n",
      "Iteration 91 with loss 5.605697515420616e-05\n",
      "Iteration 92 with loss 8.074503421084955e-05\n",
      "Iteration 93 with loss 0.00013490313722286373\n",
      "Iteration 94 with loss 5.471059921546839e-05\n",
      "Iteration 95 with loss 8.576268737670034e-05\n",
      "Iteration 96 with loss 0.00012361332483123988\n",
      "Iteration 97 with loss 4.54712389910128e-05\n",
      "Iteration 98 with loss 4.353806798462756e-05\n",
      "Iteration 99 with loss 6.692943861708045e-05\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# make it reproducible\n",
    "torch.manual_seed(42)\n",
    "\n",
    "# configuration\n",
    "num_hidden = 5\n",
    "dim_hidden = 5\n",
    "batch_size = 30\n",
    "num_iter = 100\n",
    "tolerance = 1e-8\n",
    "learning_rate = 1e-1\n",
    "domain = (-5.0, 5.0)\n",
    "\n",
    "# function versions of model forward, gradient and loss\n",
    "model = LinearNN(num_layers=num_hidden, num_neurons=dim_hidden, num_inputs=1)\n",
    "funcs = make_forward_fn(model, derivative_order=1)\n",
    "\n",
    "f = funcs[0]\n",
    "dfdx = funcs[1]\n",
    "loss_fn = make_loss_fn(f, dfdx)\n",
    "\n",
    "# choose optimizer with functional API using functorch\n",
    "optimizer = torchopt.FuncOptimizer(torchopt.adam(lr=learning_rate))\n",
    "\n",
    "# initial parameters randomly initialized\n",
    "params = tuple(model.parameters())\n",
    "\n",
    "# train the model\n",
    "loss_evolution = []\n",
    "for i in range(num_iter):\n",
    "\n",
    "    # sample points in the domain randomly for each epoch\n",
    "    x = torch.FloatTensor(batch_size).uniform_(domain[0], domain[1])\n",
    "\n",
    "    # compute the loss with the current parameters\n",
    "    loss = loss_fn(params, x)\n",
    "\n",
    "    # update the parameters with functional optimizer\n",
    "    params = optimizer.step(loss, params)\n",
    "\n",
    "    print(f\"Iteration {i} with loss {float(loss)}\")\n",
    "    loss_evolution.append(float(loss))\n",
    "\n",
    "# plot solution on the given domain\n",
    "x_eval = torch.linspace(domain[0], domain[1], steps=100).reshape(-1, 1)\n",
    "f_eval = f(x_eval, params)\n",
    "analytical_sol_fn = lambda x: 1.0 / (1.0 + (1.0/F_BOUNDARY - 1.0) * np.exp(-R * x))\n",
    "x_eval_np = x_eval.detach().numpy()\n",
    "x_sample_np = torch.FloatTensor(batch_size).uniform_(domain[0], domain[1]).detach().numpy()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.scatter(x_sample_np, analytical_sol_fn(x_sample_np), color=\"red\", label=\"Sample training points\")\n",
    "ax.plot(x_eval_np, f_eval.detach().numpy(), label=\"PINN final solution\")\n",
    "ax.plot(\n",
    "    x_eval_np,\n",
    "    analytical_sol_fn(x_eval_np),\n",
    "    label=f\"Analytic solution\",\n",
    "    color=\"green\",\n",
    "    alpha=0.75,\n",
    ")\n",
    "ax.set(title=\"Logistic equation solved with NNs\", xlabel=\"t\", ylabel=\"f(t)\")\n",
    "ax.legend()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.semilogy(loss_evolution)\n",
    "ax.set(title=\"Loss evolution\", xlabel=\"# epochs\", ylabel=\"Loss\")\n",
    "ax.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e21ad3c-c273-4b69-be4b-d38b7ed219a5",
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}