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 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 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": 3,
   "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": 4,
   "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": 5,
   "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": 6,
   "id": "d6ed9aaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input points: {'x0': LabelTensor([[[0.]]]), 'D': LabelTensor([[[0.8633]],\n",
      "             [[0.4009]],\n",
      "             [[0.6489]],\n",
      "             [[0.9278]],\n",
      "             [[0.3975]],\n",
      "             [[0.1484]],\n",
      "             [[0.9632]],\n",
      "             [[0.5485]],\n",
      "             [[0.2984]],\n",
      "             [[0.5643]],\n",
      "             [[0.0368]],\n",
      "             [[0.7847]],\n",
      "             [[0.4741]],\n",
      "             [[0.6957]],\n",
      "             [[0.3281]],\n",
      "             [[0.0958]],\n",
      "             [[0.1847]],\n",
      "             [[0.2232]],\n",
      "             [[0.8099]],\n",
      "             [[0.7304]]])}\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": 7,
   "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": 8,
   "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",
      "Missing logger folder: /Users/dariocoscia/Desktop/PINA/tutorials/tutorial1/lightning_logs\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1499: : 1it [00:00, 316.24it/s, v_num=0, mean_loss=5.39e-5, x0_loss=1.26e-6, D_loss=0.000106] "
     ]
    },
    {
     "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, 166.89it/s, v_num=0, mean_loss=5.39e-5, x0_loss=1.26e-6, D_loss=0.000106]\n"
     ]
    }
   ],
   "source": [
    "from pina import PINN, Trainer\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": 9,
   "id": "f5fbf362",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'mean_loss': tensor(5.3852e-05),\n",
       " 'x0_loss': tensor(1.2636e-06),\n",
       " 'D_loss': tensor(0.0001)}"
      ]
     },
     "execution_count": 9,
     "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": 12,
   "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": 14,
   "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
}