{ "cells": [ { "attachments": {}, "cell_type": "markdown", "id": "6f71ca5c", "metadata": {}, "source": [ "# Tutorial: Physics Informed Neural Networks on PINA\n", "\n", "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial1/tutorial.ipynb)\n" ] }, { "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", "

\n", " \"PINA\n", "

\n", "\n", "Specifically, the tutorial aims to introduce the following topics:\n", "\n", "* Explaining how to build **PINA** Problems,\n", "* Showing how to generate data for `PINN` training\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 using 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.domain 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 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": [ "## routine needed to run the notebook on Google Colab\n", "try:\n", " import google.colab\n", " IN_COLAB = True\n", "except:\n", " IN_COLAB = False\n", "if IN_COLAB:\n", " !pip install \"pina-mathlab\"\n", "\n", "from pina.problem import SpatialProblem, TimeDependentProblem\n", "from pina.domain 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) ``spatial_domain``\n", "* ``TimeDependentProblem`` $\\rightarrow$ a time-dependent differential equation with temporal variable(s) ``temporal_domain``\n", "* ``ParametricProblem`` $\\rightarrow$ a parametrized differential equation with parametric variable(s) ``parameter_domain``\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.operator import grad\n", "from pina import Condition\n", "from pina.domain 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", " domains ={\n", " 'x0': CartesianDomain({'x': 0.}),\n", " 'D': CartesianDomain({'x': [0, 1]})\n", " }\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", " 'bound_cond': Condition(domain='x0', equation=FixedValue(1.)),\n", " 'phys_cond': Condition(domain='D', equation=Equation(ode_equation))\n", " }\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 it 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 results, or points in the domains. In case we perform 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', domains='all')\n", "\n", "# sampling 20 points in (0, 1) through latin hypercube sampling in D, and 1 point in x0\n", "problem.discretise_domain(n=20, mode='latin', domains=['D'])\n", "problem.discretise_domain(n=1, mode='random', domains=['x0'])\n", "\n", "# sampling 20 points in (0, 1) randomly\n", "problem.discretise_domain(n=20, mode='random')" ] }, { "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', domains=['x0']) # TODO check\n", "problem.discretise_domain(20, 'lh', domains=['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.3579],\n", " [0.4598],\n", " [0.2735],\n", " [0.5365],\n", " [0.9781],\n", " [0.0321],\n", " [0.0510],\n", " [0.8479],\n", " [0.6835],\n", " [0.5861],\n", " [0.8708],\n", " [0.9179],\n", " [0.1901],\n", " [0.4485],\n", " [0.7348],\n", " [0.6365],\n", " [0.7517],\n", " [0.1215],\n", " [0.3379],\n", " [0.2152]])}\n", "Input points labels: ['x']\n" ] } ], "source": [ "print('Input points:', problem.discretised_domains)\n", "print('Input points labels:', problem.discretised_domains['D'].labels)" ] }, { "cell_type": "markdown", "id": "669e8534", "metadata": {}, "source": [ "To visualize the sampled points we can use `matplotlib.pyplot`:" ] }, { "cell_type": "code", "execution_count": 6, "id": "3802e22a", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "variables=problem.spatial_variables\n", "fig = plt.figure()\n", "proj = \"3d\" if len(variables) == 3 else None\n", "ax = fig.add_subplot(projection=proj)\n", "for location in problem.input_pts:\n", " coords = problem.input_pts[location].extract(variables).T.detach()\n", " ax.plot(coords.flatten(),torch.zeros(coords.flatten().shape),\".\",label=location)\n" ] }, { "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.solver`. 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 `lightning` 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", "HPU available: False, using: 0 HPUs\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f87fba27dd664812a8745af6b2adcce2", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: | | 0/? [00:00" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "pts = pinn.problem.spatial_domain.sample(256, 'grid', variables='x')\n", "predicted_output = pinn.forward(pts).extract('u').as_subclass(torch.Tensor).cpu().detach()\n", "true_output = pinn.problem.truth_solution(pts).cpu().detach()\n", "pts = pts.cpu()\n", "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8, 8))\n", "ax.plot(pts.extract(['x']), predicted_output, label='Neural Network solution')\n", "ax.plot(pts.extract(['x']), true_output, label='True solution')\n", "plt.legend()" ] }, { "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": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "list_ = [\n", " idx for idx, s in enumerate(trainer.callbacks)\n", " if isinstance(s, MetricTracker)\n", " ]\n", "trainer_metrics = trainer.callbacks[list_[0]].metrics\n", "\n", "loss = trainer_metrics['val_loss']\n", "epochs = range(len(loss))\n", "plt.plot(epochs, loss.cpu())\n", "# plotting\n", "plt.xlabel('epoch')\n", "plt.ylabel('loss')\n", "plt.yscale('log')" ] }, { "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", "Congratulations on completing the introductory tutorial of **PINA**! There are several 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 training and speed benchmarking\n", "\n", "4. Many more..." ] } ], "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.12.7" } }, "nbformat": 4, "nbformat_minor": 5 }