PINA/tutorials/tutorial1/tutorial.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6f71ca5c",
   "metadata": {},
   "source": [
    "# Tutorial: Physics Informed Neural Networks on PINA"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ef4949c9",
   "metadata": {},
   "source": [
    "In this tutorial, we will demonstrate a typical use case of **PINA** on a toy problem, following the standard API procedure. \n",
    "\n",
    "<p align=\"center\">\n",
    "    <img src=\"../../readme/API_color.png\" alt=\"PINA API\" width=\"400\"/>\n",
    "</p>\n",
    "\n",
    "Specifically, the tutorial aims to introduce the following topics:\n",
    "\n",
    "* Explaining how to build **PINA** Problem,\n",
    "* Showing how to generate data for `PINN` straining\n",
    "\n",
    "These are the two main steps needed **before** starting the modelling optimization (choose model and solver, and train). We will show each step in detail, and at the end, we will solve a simple Ordinary Differential Equation (ODE) problem busing the `PINN` solver."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "cf9c96e3",
   "metadata": {},
   "source": [
    "## Build a PINA problem"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8a819659",
   "metadata": {},
   "source": [
    "Problem definition in the **PINA** framework is done by building a python `class`, which inherits from one or more problem classes (`SpatialProblem`, `TimeDependentProblem`, `ParametricProblem`, ...) depending on the nature of the problem. Below is an example:\n",
    "### Simple Ordinary Differential Equation\n",
    "Consider the following:\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "\\begin{cases}\n",
    "\\frac{d}{dx}u(x) &=  u(x) \\quad x\\in(0,1)\\\\\n",
    "u(x=0) &= 1 \\\\\n",
    "\\end{cases}\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "with the analytical solution $u(x) = e^x$. In this case, our ODE depends only on the spatial variable $x\\in(0,1)$ , meaning that our `Problem` class is going to be inherited from the `SpatialProblem` class:\n",
    "\n",
    "```python\n",
    "from pina.problem import SpatialProblem\n",
    "from pina.geometry import CartesianProblem\n",
    "\n",
    "class SimpleODE(SpatialProblem):\n",
    "    \n",
    "    output_variables = ['u']\n",
    "    spatial_domain = CartesianProblem({'x': [0, 1]})\n",
    "\n",
    "    # other stuff ...\n",
    "```\n",
    "\n",
    "Notice that we define `output_variables` as a list of symbols, indicating the output variables of our equation (in this case only $u$), this is done because in **PINA** the `torch.Tensor`s are labelled, allowing the user maximal flexibility for the manipulation of the tensor. The `spatial_domain` variable indicates where the sample points are going to be sampled in the domain, in this case $x\\in[0,1]$.\n",
    "\n",
    "What about if our equation is also time dependent? In this case, our `class` will inherit from both `SpatialProblem` and `TimeDependentProblem`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2373a925",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pina.problem import SpatialProblem, TimeDependentProblem\n",
    "from pina.geometry import CartesianDomain\n",
    "\n",
    "class TimeSpaceODE(SpatialProblem, TimeDependentProblem):\n",
    "    \n",
    "    output_variables = ['u']\n",
    "    spatial_domain = CartesianDomain({'x': [0, 1]})\n",
    "    temporal_domain = CartesianDomain({'t': [0, 1]})\n",
    "\n",
    "    # other stuff ..."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ad8566b8",
   "metadata": {},
   "source": [
    "where we have included the `temporal_domain` variable, indicating the time domain wanted for the solution.\n",
    "\n",
    "In summary, using **PINA**, we can initialize a problem with a class which inherits from different base classes: `SpatialProblem`, `TimeDependentProblem`, `ParametricProblem`, and so on depending on the type of problem we are considering. Here are some examples (more on the official documentation):\n",
    "* `SpatialProblem` $\\rightarrow$ a differential equation with spatial variable(s)\n",
    "* `TimeDependentProblem` $\\rightarrow$ a time-dependent differential equation\n",
    "* `ParametricProblem` $\\rightarrow$ a parametrized differential equation\n",
    "* `AbstractProblem` $\\rightarrow$ any **PINA** problem inherits from here"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "592a4c43",
   "metadata": {},
   "source": [
    "### Write the problem class\n",
    "\n",
    "Once the `Problem` class is initialized, we need to represent the differential equation in **PINA**. In order to do this, we need to load the **PINA** operators from `pina.operators` module. Again, we'll consider Equation (1) and represent it in **PINA**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f2608e2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pina.problem import SpatialProblem\n",
    "from pina.operators import grad\n",
    "from pina import Condition\n",
    "from pina.geometry import CartesianDomain\n",
    "from pina.equation import Equation, FixedValue\n",
    "\n",
    "import torch\n",
    "\n",
    "\n",
    "class SimpleODE(SpatialProblem):\n",
    "\n",
    "    output_variables = ['u']\n",
    "    spatial_domain = CartesianDomain({'x': [0, 1]})\n",
    "\n",
    "    # defining the ode equation\n",
    "    def ode_equation(input_, output_):\n",
    "\n",
    "        # computing the derivative\n",
    "        u_x = grad(output_, input_, components=['u'], d=['x'])\n",
    "\n",
    "        # extracting the u input variable\n",
    "        u = output_.extract(['u'])\n",
    "\n",
    "        # calculate the residual and return it\n",
    "        return u_x - u\n",
    "\n",
    "    # conditions to hold\n",
    "    conditions = {\n",
    "        'x0': Condition(location=CartesianDomain({'x': 0.}), equation=FixedValue(1)),             # We fix initial condition to value 1\n",
    "        'D': Condition(location=CartesianDomain({'x': [0, 1]}), equation=Equation(ode_equation)), # We wrap the python equation using Equation\n",
    "    }\n",
    "\n",
    "    # sampled points (see below)\n",
    "    input_pts = None\n",
    "\n",
    "    # defining the true solution\n",
    "    def truth_solution(self, pts):\n",
    "        return torch.exp(pts.extract(['x']))\n",
    "    \n",
    "problem = SimpleODE()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7cf64d01",
   "metadata": {},
   "source": [
    "After we define the `Problem` class, we need to write different class methods, where each method is a function returning a residual. These functions are the ones minimized during PINN optimization, given the initial conditions. For example, in the domain $[0,1]$, the ODE equation (`ode_equation`) must be satisfied. We represent this by returning the difference between subtracting the variable `u` from its gradient (the residual), which we hope to minimize to 0. This is done for all conditions. Notice that we do not pass directly a `python` function, but an `Equation` object, which is initialized with the `python` function. This is done so that all the computations, and internal checks are done inside **PINA**.\n",
    "\n",
    "Once we have defined the function, we need to tell the neural network where these methods are to be applied. To do so, we use the `Condition` class. In the `Condition` class, we pass the location points and the equation we want minimized on those points (other possibilities are allowed, see the documentation for reference).\n",
    "\n",
    "Finally, it's possible to define a `truth_solution` function, which can be useful if we want to plot the results and see how the real solution compares to the expected (true) solution. Notice that the `truth_solution` function is a method of the `PINN` class, but is not mandatory for problem definition.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "78b30f95",
   "metadata": {},
   "source": [
    "## Generate data \n",
    "\n",
    "Data for training can come in form of direct numerical simulation reusults, or points in the domains. In case we do unsupervised learning, we just need the collocation points for training, i.e. points where we want to evaluate the neural network. Sampling point in **PINA** is very easy, here we show three examples using the `.discretise_domain` method of the `AbstractProblem` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "09ce5c3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# sampling 20 points in [0, 1] through discretization in all locations\n",
    "problem.discretise_domain(n=20, mode='grid', variables=['x'], locations='all')\n",
    "\n",
    "# sampling 20 points in (0, 1) through latin hypercube samping in D, and 1 point in x0\n",
    "problem.discretise_domain(n=20, mode='latin', variables=['x'], locations=['D'])\n",
    "problem.discretise_domain(n=1, mode='random', variables=['x'], locations=['x0'])\n",
    "\n",
    "# sampling 20 points in (0, 1) randomly\n",
    "problem.discretise_domain(n=20, mode='random', variables=['x'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fbb679f",
   "metadata": {},
   "source": [
    "We are going to use latin hypercube points for sampling. We need to sample in all the conditions domains. In our case we sample in `D` and `x0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "329962b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# sampling for training\n",
    "problem.discretise_domain(1, 'random', locations=['x0'])\n",
    "problem.discretise_domain(20, 'lh', locations=['D'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca2ac5c2",
   "metadata": {},
   "source": [
    "The points are saved in a python `dict`, and can be accessed by calling the attribute `input_pts` of the problem "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d6ed9aaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input points: {'x0': LabelTensor([[[0.]]]), 'D': LabelTensor([[[0.7644]],\n",
      "             [[0.2028]],\n",
      "             [[0.1789]],\n",
      "             [[0.4294]],\n",
      "             [[0.3239]],\n",
      "             [[0.6531]],\n",
      "             [[0.1406]],\n",
      "             [[0.6062]],\n",
      "             [[0.4969]],\n",
      "             [[0.7429]],\n",
      "             [[0.8681]],\n",
      "             [[0.3800]],\n",
      "             [[0.5357]],\n",
      "             [[0.0152]],\n",
      "             [[0.9679]],\n",
      "             [[0.8101]],\n",
      "             [[0.0662]],\n",
      "             [[0.9095]],\n",
      "             [[0.2503]],\n",
      "             [[0.5580]]])}\n",
      "Input points labels: ['x']\n"
     ]
    }
   ],
   "source": [
    "print('Input points:', problem.input_pts)\n",
    "print('Input points labels:', problem.input_pts['D'].labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "669e8534",
   "metadata": {},
   "source": [
    "To visualize the sampled points we can use the `.plot_samples` method of the `Plotter` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "33cc80bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pina import Plotter\n",
    "\n",
    "pl = Plotter()\n",
    "pl.plot_samples(problem=problem)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "22e502dd",
   "metadata": {},
   "source": [
    "## Perform a small training"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "075f43f5",
   "metadata": {},
   "source": [
    "Once we have defined the problem and generated the data we can start the modelling. Here we will choose a `FeedForward` neural network available in `pina.model`, and we will train using the `PINN` solver from `pina.solvers`. We highlight that this training is fairly simple, for more advanced stuff consider the tutorials in the ***Physics Informed Neural Networks*** section of ***Tutorials***. For training we use the `Trainer` class from `pina.trainer`. Here we show a very short training and some method for plotting the results. Notice that by default all relevant metrics (e.g. MSE error during training) are going to be tracked using a `lightining` logger, by default `CSVLogger`. If you want to track the metric by yourself without a logger, use `pina.callbacks.MetricTracker`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3bb4dc9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: False, used: False\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1499: : 1it [00:00, 272.55it/s, v_num=3, x0_loss=7.71e-6, D_loss=0.000734, mean_loss=0.000371]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`Trainer.fit` stopped: `max_epochs=1500` reached.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1499: : 1it [00:00, 167.14it/s, v_num=3, x0_loss=7.71e-6, D_loss=0.000734, mean_loss=0.000371]\n"
     ]
    }
   ],
   "source": [
    "from pina import Trainer\n",
    "from pina.solvers import PINN\n",
    "from pina.model import FeedForward\n",
    "from pina.callbacks import MetricTracker\n",
    "\n",
    "\n",
    "# build the model\n",
    "model = FeedForward(\n",
    "    layers=[10, 10],\n",
    "    func=torch.nn.Tanh,\n",
    "    output_dimensions=len(problem.output_variables),\n",
    "    input_dimensions=len(problem.input_variables)\n",
    ")\n",
    "\n",
    "# create the PINN object\n",
    "pinn = PINN(problem, model)\n",
    "\n",
    "# create the trainer\n",
    "trainer = Trainer(solver=pinn, max_epochs=1500, callbacks=[MetricTracker()], accelerator='cpu', enable_model_summary=False) # we train on CPU and avoid model summary at beginning of training (optional)\n",
    "\n",
    "# train\n",
    "trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8b4f496",
   "metadata": {},
   "source": [
    "After the training we can inspect trainer logged metrics (by default **PINA** logs mean square error residual loss). The logged metrics can be accessed online using one of the `Lightinig` loggers. The final loss can be accessed by `trainer.logged_metrics`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f5fbf362",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'x0_loss': tensor(7.7149e-06),\n",
       " 'D_loss': tensor(0.0007),\n",
       " 'mean_loss': tensor(0.0004)}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# inspecting final loss\n",
    "trainer.logged_metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0963d7d2",
   "metadata": {},
   "source": [
    "By using the `Plotter` class from **PINA** we can also do some quatitative plots of the solution. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "19078eb5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plotting the solution\n",
    "pl.plot(solver=pinn)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf47b98a",
   "metadata": {},
   "source": [
    "The solution is overlapped with the actual one, and they are barely indistinguishable. We can also plot easily the loss:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bf6211e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pl.plot_loss(trainer=trainer, label = 'mean_loss', logy=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58172899",
   "metadata": {},
   "source": [
    "As we can see the loss has not reached a minimum, suggesting that we could train for longer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33e672da",
   "metadata": {},
   "source": [
    "## What's next?\n",
    "\n",
    "Nice you have completed the introductory tutorial of **PINA**! There are multiple directions you can go now:\n",
    "\n",
    "1. Train the network for longer or with different layer sizes and assert the finaly accuracy\n",
    "\n",
    "2. Train the network using other types of models (see `pina.model`)\n",
    "\n",
    "3. GPU trainining and benchmark the speed\n",
    "\n",
    "4. Many more..."
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
  },
  "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}