From 9691175ef9b6de49ac79dd936f0771da095d5b50 Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Fri, 9 Dec 2022 16:39:13 +0100 Subject: [PATCH 01/30] add/change information of tutorial Signed-off-by: Tom Freudenberg --- docs/examples.rst | 25 +- docs/tutorial/condition_tutorial.rst | 16 +- docs/tutorial/sampler_tutorial.rst | 17 +- docs/tutorial/solve_pde.rst | 3 +- docs/tutorial/solver_info.rst | 69 ++++ docs/tutorial/tutorial_start.rst | 16 +- examples/pinn/hard-constrains.ipynb | 556 +++++++++++++++++++++++++++ 7 files changed, 686 insertions(+), 16 deletions(-) create mode 100644 docs/tutorial/solver_info.rst create mode 100644 examples/pinn/hard-constrains.ipynb diff --git a/docs/examples.rst b/docs/examples.rst index 23f944e8..dc9989ac 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -20,7 +20,7 @@ One of the simplest applications is the forward solution of a Poisson equation: u &= \sin(\frac{\pi}{2} x_1)\cos(2\pi x_2), \text{ on } \partial \Omega \end{align} -This problem is part of the tutorial and only mentioned for completeness. +This problem is part of the tutorial and is therefore explained with alot of details. The corresponding implementation can be found here_. .. _here : tutorial/solve_pde.html @@ -38,7 +38,7 @@ A simple example would be the problem: u(0) &= 1 \end{align*} -where we want to train a family of solutions for :math:`k \in [0, 2]`. So we essentially +where we want to train a family of solutions for :math:`k \in [0, 2]`. We want to find the function :math:`u(x, k) = e^{kx}`. Implemented is this example in: `simple-parameter-dependency-notebook`_ @@ -96,6 +96,27 @@ Link to the notebook: `moving-domain-notebook`_ .. _`moving-domain-notebook`: https://github.com/boschresearch/torchphysics/blob/main/examples/pinn/moving-heat-equation.ipynb + +Using hard constrains +===================== +For some problems, it is advantageous to build some prior knowledge into the used network architecture +(e.g. scaling the network output or fixing the values on the boundary). This can easily be achieved +in TorchPhysics and is demonstrated in this `hard-constrains-notebook`_. There we consider the system: + +.. math:: + + \begin{align*} + \partial_y u(x,y) &= \frac{u(x,y)}{y}, \text{ in } [0, 1] \times [0, 1] \\ + u_1(x, 0) &= 0 , \text{ for } x \in [0, 1] \\ + u_2(x, 1) &= \sin(20\pi*x) , \text{ for } x \in [0, 1] \\ + \vec{n} \nabla u(x, y) &= 0 , \text{ for } x \in \{0, 1\}, y \in \{0, 1\}\\ + \end{align*} + +where the high frequency is problematic for the usual PINN-approach. + +.. _`hard-constrains-notebook`: https://github.com/boschresearch/torchphysics/blob/main/examples/pinn/hard-constrains.ipynb + + Interface jump ============== For an example where we want to solve a problem with a discontinuous solution, diff --git a/docs/tutorial/condition_tutorial.rst b/docs/tutorial/condition_tutorial.rst index d2954623..d0ac1d25 100644 --- a/docs/tutorial/condition_tutorial.rst +++ b/docs/tutorial/condition_tutorial.rst @@ -4,7 +4,7 @@ Conditions The **Conditions** are the central concept of TorchPhysics. They transform the conditions of the underlying differential equation into the trainings conditions for the neural network. -Many kinds of conditions are pre implemented, they can be found under +Many kinds of conditions are pre implemented, they can be found in the docs_. Depending on the used type, the condition get different inputs. The five arguments that almost all conditions need, are: @@ -65,7 +65,7 @@ need the output ``u`` and the input ``t`` and ``x``. Therefore the corresponding def boundary_residual(u, t, x): return u - torch.sin(t * x[:, :1])*torch.sin(t * x[:, 1:]) -Here many important things are happening: +Here many **important** things are happening: 1) The inputs of the function ``boundary_residual`` only corresponds to the variables required. The needed variables will then internally be correctly passed to the method. Here it is important @@ -76,10 +76,22 @@ Here many important things are happening: If we assume ``x`` is two-dimensional the value ``x[:, :1]`` corresponds to the entries of the first axis, while ``x[:, 1:]`` is the second axis. One could also write something like ``t[:, :1]``, but this is equal to ``t``. + Maybe now the question arises, if one could also use ``x[:, 0]`` instead of ``x[:, :1]``. + Both expressions return the first axis of our two-dimensional input points. **But** + there is one important difference in the output, the final **shape**. The use of + ``x[:, 0]`` leads to an output of the shape: [batch-dimension] (essentially just + a list/tensor with the values of the first axis), while ``x[:, :1]`` has the + shape: [batch-dimension, 1]. So ``x[:, :1]`` preserves the shape of the + input. This is important to get the correct behavior for different operations like + addition, multiplication, etc. Therefore, ``x[:, 0]`` should generally not be used + inside the residuals and can even lead to errors while training. For more info + on tensor shapes one should check the documentation of `PyTorch`_. 4) The output at the end has to be a PyTorch tensor. 5) We have to rewrite the residual in such a way, that the right hand side is zero. E.g. here we have to bring the sin-function to the other side. +.. _`PyTorch`: https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html + The defined method could then be passed to a condition. Let us assume we have already created our model and sampler: diff --git a/docs/tutorial/sampler_tutorial.rst b/docs/tutorial/sampler_tutorial.rst index 3e501af6..c837899f 100644 --- a/docs/tutorial/sampler_tutorial.rst +++ b/docs/tutorial/sampler_tutorial.rst @@ -30,7 +30,7 @@ created with: import torchphysics as tp X = tp.spaces.R2('x') # the space of the object R = tp.domains.Parallelogram(X, [0, 0], [1, 0], [0, 1]) # unit square - C = tp.domains.Circle(X, [0, 0], 1)  # unit circle + C = tp.domains.Circle(X, [0, 0], 1) # unit circle random_R = tp.samplers.RandomUniformSampler(R, n_points=50) # 50 random points in R grid_C = tp.samplers.GridSampler(C, density=10) # grid points with density 10 in C @@ -51,6 +51,20 @@ be used in the following way: # first argument the space, afterwards all samplers: tp.utils.scatter(X, random_R, random_R_bound) +To create on batch of points, the ``.sample_points()`` method can be used. This functions +creates ``n_points`` (or density dependent) different points with the desired sampling strategy +and returns the corresponding ``Points`` object: + +.. code-block:: python + + created_points = random_R.sample_points() + +The utilities of the ``Points`` objects were part of the `spaces and points tutorial`_. +As a general reminder, these ``created_points`` are essentially a dictionary with the +different space variables as keys and PyTorch-tensors as values. To extract a stacked +PyTorch-tensor of all values, one can use the property ``.as_tensor``. Generally the +``.sample_points()`` function will be called only internally. + The default behavior of each sampler is, that in each iteration of the trainings process new points are created and used. If this is not desired, not useful (grid sampling) or not efficient (e.g. really complex domains) one can make every sampler ``static``. This will @@ -118,4 +132,5 @@ found in the `sampler-docs`_. Now you know all about the creation of points and can either go to the conditions or definition of neural networks. Click here_ to go back to the main tutorial page. +.. _`spaces and points tutorial`: tutorial_spaces_and_points.html .. _here: tutorial_start.html \ No newline at end of file diff --git a/docs/tutorial/solve_pde.rst b/docs/tutorial/solve_pde.rst index 41149783..85b809b7 100644 --- a/docs/tutorial/solve_pde.rst +++ b/docs/tutorial/solve_pde.rst @@ -101,8 +101,7 @@ Pytorch Lightning can be applied in the trainings process. .. code-block:: python import pytorch_lightning as pl - import os - os.environ["CUDA_VISIBLE_DEVICES"] = "0" # select GPUs to use + trainer = pl.Trainer(gpus=1, # or None if CPU is used max_steps=4000, # number of training steps logger=False, diff --git a/docs/tutorial/solver_info.rst b/docs/tutorial/solver_info.rst new file mode 100644 index 00000000..c2fdfd04 --- /dev/null +++ b/docs/tutorial/solver_info.rst @@ -0,0 +1,69 @@ +================================== +Info about the Solver and Training +================================== +For solving a differential equation and training the neural network, we use the +library Pytorch Lightning. This lets us easily handles the training and validation +loops and take care of the data loading/creation. + +To see the solver class in action, we refer to the `beginning example`_ of the tutorial. +There, the behavior of the TorchPhysics ``Solver`` is explained and shown. +Here we rather want to mention some more details for the trainings process. + +In general, most of the capabilities of Pytorch Lightning can also be used inside +TorchPhysics. All possiblities can be checked in the `Lightning documentation`_. + +.. _`beginning example`: solve_pde.html +.. _`Lightning documentation`: https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html + +Given some TorchPhysics ``Solver``, that already contains all information of our problem, +the basic trainer is defined as follows: + +.. code-block:: python + + import pytorch_lightning as pl + + trainer = pl.Trainer(gpus=1, max_steps=4000, check_val_every_n_epoch=10) + trainer.fit(solver) # start training + +Some important keywords are: + +- **gpus**: The number of GPUs that should be used. If only one or more CPUs are available + set ```gpus=None``. Depending on the operating system, the GPUs may have to be further + specified beforehand via ``os.environ`` or other ways. There are more different possiblities to + specify the used device, see the above mentionde documentation. +- **max_steps**: The maximum number of training iterations. In each iteration + all defined training conditions will be evaluated + (e.g. points sampled, model output computed, residuals evaluated, etc.) and a + gradient descent step will be made. +- **check_val_every_n_epoch**: Defines how often the validation data should be checked. + +Logging Data +------------ +Using the above definition for the ``trainer`` will lead while training to the creation of a folder named +*lightning_logs* inside the current directory. Inside this folder, data about the current training +process is saved. In TorchPhysics this data includes the loss of each training condition, over the +course of all iterations, and the total loss. +(Here it is important to give each condition a unique ``name``, or the data may be overwritten) + +While the training is running, or afterwards, the loss can be monitored inside TensorBoard, if installed. +For this, use inside a terminal: + +.. code-block:: console + + tensorboard --logdir path_to_log_folder + +Which will open a new window inside your browser to visualize the data. Some important keywords of +the ``pl.Trainer`` regarding logging are: + +- **logger**: A ``TensorBoardLogger`` that defines the saving behavior. As default, a Logger with +the above mentioned aspects is used. Setting ``logger=False`` will disable logging. +- **log_every_n_steps**: How often data should be saved. + +Callbacks +--------- +Callbacks are an additional versatile option to monitor the training or apply custom logic, while +training. For example, via Callbacks the learned solution can be plotted to TensorBoard or after +every few steps the trained network can be saved. Different callbacks can be created via +``pytorch_lightning.callbacks``. Already implemented callbacks in TorchPhysics are found under +the ``torchphysics.utils`` section. A list of all created callbacks can then be passed to the trainer +with the ``callbacks`` keyword. \ No newline at end of file diff --git a/docs/tutorial/tutorial_start.rst b/docs/tutorial/tutorial_start.rst index b5ef674f..951cab0c 100644 --- a/docs/tutorial/tutorial_start.rst +++ b/docs/tutorial/tutorial_start.rst @@ -41,6 +41,13 @@ Conditions induced by the differential equation. See `condition tutorial`_ on how to create different kinds of conditions for all parts of the problem. +Solver + Handles the training of the defined model, by applying the previously created conditions. + The usage of the solver is shown the beginnig example for `solving a simple PDE`_. More details + of the trainings process are mentioned here_. + +.. _here: solver_info.html + Utils Implement a variety of helper functions to make the definition and evaluation of problems easier. To get an overview of all methods, see the docs_. Two parts that will @@ -49,15 +56,6 @@ Utils - The usage of the pre implemented `differential operators`_ - `Creating plots`_ of the trained solutions. -Solver - Handles the training of the defined model, by applying the previously created conditions. - The usage of the solver will be shown in a complete problem, where all the above parts of the library - are used. This is shown in `solving a simple PDE`_. - -These are all the basics of TorchPhysics. You should now have a rough understanding of the -structure of this library. Some additional applications (inverse problems, training input params, ...) -can be found under the `example-folder`_ - .. _`spaces and points tutorial`: tutorial_spaces_and_points.html .. _`Domain basics`: tutorial_domain_basics.html .. _`Polygons and external objects`: external_domains.html diff --git a/examples/pinn/hard-constrains.ipynb b/examples/pinn/hard-constrains.ipynb new file mode 100644 index 00000000..31d88ac3 --- /dev/null +++ b/examples/pinn/hard-constrains.ipynb @@ -0,0 +1,556 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Applying hard constraints \n", + "\n", + "For some problems, it is advantageous to apply prior knowledge about the solution in the network architecture, instead of the training process via additional loss terms. For example, in simple domains a Dirichlet boundary condition could be added to the network output with a corresponding characteristic function. Since the boundary condition is then naturally fulfilled, one has to consider fewer terms in the final loss and the optimization may become easier.\n", + "\n", + "Additionally, for some specific function types (e.g. high frequencies) hard constraints may even be needed to get reasonable results. In this notebook, we give one simple example for such a case and show how to use hard constrains in TorchPhysics. Generally, one has to carefully choose what constraints should be applied to the network, depending on the given problem. Using wrong constraints may even worsen the learned solution.\n", + "\n", + "Here we consider the example:\n", + "\\begin{align*}\n", + " \\partial_y u(x,y) &= \\frac{u(x,y)}{y}, \\text{ in } [0, 1] \\times [0, 1] \\\\\n", + " u_1(x, 0) &= 0 , \\text{ for } x \\in [0, 1] \\\\\n", + " u_2(x, 1) &= \\sin(20\\pi*x) , \\text{ for } x \\in [0, 1] \\\\\n", + " \\vec{n} \\nabla u(x, y) &= 0 , \\text{ for } x \\in \\{0, 1\\}, y \\in \\{0, 1\\}\\\\\n", + "\\end{align*}\n", + "This problem has the simple solution $u(x, y) = y\\sin(20\\pi x)$. But because of the high frequencies of the sinus term, a training of the boundary condition is rather problematic. One reason for this is the usage of the MSE inside the loss function, which promotes to just learn the mean value of our boundary function. Another reason is the spectral bias of neural networks.\n", + "\n", + "In the following, the problem is firstly implemented the normal way, where all above equations are used to define different loss terms. This will not lead to a correct/useful solution. (Until the first results, no comments will be given regarding the implementation. Since just the basics are used)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\" # select GPUs to use\n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl\n", + "import torch\n", + "import math" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "X = tp.spaces.R1('x')\n", + "Y = tp.spaces.R1('y')\n", + "XY = X*Y\n", + "U = tp.spaces.R1('u')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "x_axis = tp.domains.Interval(X, 0, 1)\n", + "y_axis = tp.domains.Interval(Y, 0, 1)\n", + "square = tp.domains.Parallelogram(XY, [0,0], [1,0], [0,1])\n", + "\n", + "def bc_fn(x):\n", + " return torch.cos(20*math.pi*x)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "model = tp.models.FCN(input_space=XY, output_space=U, hidden=(50, 50, 50, 50))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "inner_sampler = tp.samplers.RandomUniformSampler(square, n_points=50000)\n", + "tol = 0.0001 # to not devide by small numbers\n", + "\n", + "def pde_residual(u, x, y):\n", + " return tp.utils.grad(u, y) - u/(y + tol)\n", + "\n", + "\n", + "pde_condition = tp.conditions.PINNCondition(module=model,\n", + " sampler=inner_sampler,\n", + " residual_fn=pde_residual,\n", + " name='pde_condition')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "y_sampler = tp.samplers.RandomUniformSampler(x_axis*y_axis.boundary, n_points=20000)\n", + "\n", + "def dirichlet_residual(u, x, y):\n", + " return u - y * bc_fn(x)\n", + "\n", + "dirichlet_condition = tp.conditions.PINNCondition(module=model,\n", + " sampler=y_sampler,\n", + " residual_fn=dirichlet_residual,\n", + " name='diri_condition')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "x_sampler = tp.samplers.RandomUniformSampler(x_axis.boundary*y_axis, n_points=20000)\n", + "\n", + "def neumann_residual(u, x):\n", + " return tp.utils.grad(u, x) # = 0\n", + "\n", + "neumann_condition = tp.conditions.PINNCondition(module=model,\n", + " sampler=x_sampler,\n", + " residual_fn=neumann_residual,\n", + " name='neu_condition', weight=1/60)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 7.9 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "7.9 K Trainable params\n", + "0 Non-trainable params\n", + "7.9 K Total params\n", + "0.031 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3ee03e0991f6495dba1e6cec6f532af7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "659dea1a777e437ebd97bb2a9ee84c20", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1722666190714616ad33a236396dc3fe", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.001)\n", + "\n", + "solver = tp.solver.Solver([pde_condition, dirichlet_condition, neumann_condition], optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " max_steps=5000,\n", + " logger=False,\n", + " benchmark=True,\n", + " checkpoint_callback=False)\n", + " \n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The training was done with Adam and a learning rate of 0.001 and just for 5000 iterations. But choosing different algorithms or values will not improve the results. The loss will in general hover around some constant value near 0.25.\n", + "\n", + "Having a look at the learned solution, most of the time we either get a solution that is close to zero or has just captured a few oscillations of the boundary function. The results are never good." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/torch/functional.py:478: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:2895.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n", + "/home/tomfre/Desktop/torchphysics/src/torchphysics/problem/domains/domain2D/parallelogram.py:134: UserWarning: The use of `x.T` on tensors of dimension other than 2 to reverse their shape is deprecated and it will throw an error in a future release. Consider `x.mT` to transpose batches of matricesor `x.permute(*torch.arange(x.ndim - 1, -1, -1))` to reverse the dimensions of a tensor. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:2985.)\n", + " bary_coords = torch.stack(torch.meshgrid((x, y))).T.reshape(-1, 2)\n", + "/home/tomfre/Desktop/torchphysics/src/torchphysics/utils/plotting/plot_functions.py:416: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:204.)\n", + " embed_point = Points(torch.tensor([center]), domain.space)\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'learned solution')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plot_sampler = tp.samplers.PlotSampler(plot_domain=square, n_points=2000)\n", + "fig = tp.utils.plot(model, lambda u: u, plot_sampler, plot_type='contour_surface')\n", + "plt.title('learned solution')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'error')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEWCAYAAABv+EDhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABx7UlEQVR4nO29e7hkV1nn/3mrT586Vef0vZM2nSZ2JhekJ2BCmoABpCORiXEIzoAIDgjzAzM/HeammQEf51EGh5+AiaOOjoiX4eYYIyJEiYLENMyAQDoTLqGRpEma0OmQpO85XdV1+vR5f3+statW7Vp777V37Tq32t/nqefUqdq17ut93/XelqgqFSpUqFBh/FBb6gZUqFChQoWlQcUAKlSoUGFMUTGAChUqVBhTVAygQoUKFcYUFQOoUKFChTFFxQAqVKhQYUxRMYAKFSpUGFNUDKBChQoVxhQVA6iwYiEiE7H/RUSC13Te5ytUWG2oFn+FZQcR2S4ify4iT4nIIyLyb+3nbxeRj4jIh0XkFPBGEdkrIu8Ukc8BLeAfici1InKviJy0f691yh54fkk6WaHCMkDFACosK1iJ/C+BrwAXAi8F/r2I/BP7yCuAjwAbgT+2n70euBlYBzwNfAL4LWAL8OvAJ0Rki1ON+/y3R9idChWWNSoGUGG54XnAear6DlWdU9WHgd8HXmO//3tV/ZiqLqhq2372flX9uqrOAy8DHlLVD6nqvKr+CfAPwMudOrrPq+rZxepYhQrLDRPZj1SosKj4XmC7iJxwPlsD/G+MtP4dz2/cz7YzKNV/G3Oa8D1focLYojoBVFhu+A7wiKpudF7rVPVG+70vfa372WEME3FxEfBYwvMVKowtKgZQYbnhS8DTIvJWEWmIyBoRuUJEnhf4+7uAy0XkJ0VkQkR+AtgF/NXIWlyhwgpFxQAqLCuo6jngnwJXAo8AR4A/ADYE/v6o/f3PA0eB/wT8U1U9Mor2VqiwkiHVhTAVKlSoMJ6oTgAVKlSoMKaoGECFChUqjCkqBlChQoUKY4qKAVSoUKHCmGLFBYJt3bpVd+7cGfz86dOnmZ6eHl2DFgFVH5YeK739MJ59uO+++46o6nnD1Hm5iJ4OfPYwfFJVbximvsXEimMAO3fuZN++fcHP7927lz179oyuQYuAqg9Lj5XefhjPPojI0LmeTgM/G/jsf4atw9a3mKhUQBUqVKgwplhxJ4AKFSpUWEzUgMZSN2JEqE4AFSpUqDCmqE4AFSpUqJCCNcD6pW7EiFCdACpUqFBhTDEyBiAifyQiT4rIAwnfi4j8logcEJGvishzR9WWChUqVCiKyAYQ8lppGOUJ4P1Amj/sjwCX2dfNwO+OsC0VKlSoUCGGkdkAVPWzIrIz5ZFXAB9Uk470CyKyUUQuUNXHR9WmChUqVMiL1WwDWEoj8IX0X813yH42wABE5GbMKYFt27axd+/e4EpmZ2e57bZPwNQ0bIPJrR02c4xNHKc524aTwBww3/s7Nw8LwNQEcB7wPXC0toljbOHU7AZ4wj67YCuJ/k4CF8D0+lm2cIQtepTaU5jno2dqmFGfsO/XABuhs3GSY2zmGJs5c7QB3wXOnIPaGnbsmOW2P9wLU8AU1DbNs6l2nC0cY93crMmY/xQcmTdVzABTU8A00DQfzDdrnGQDJ9nA8flNcLQGx4DWGdOQqUmTcX8jTM50WMcpNnCSdTzNxKkFM04n4OQctG3zt9RANgGb4ez6CU7Y8p9eWMfC7AScwlzR3oIdO05y23/fa8Zz6wKbJo6zieNsWjgJs8AZ8xwd0Ba0FsyUrK+BbDXz8PTUDEfZzNH5LXCkZn5ztn/uojmY3NphK0fYzDHqJ+bgKft9hAXnfc30gfPgqdoWjrGF2VPrzLydMp3dsX2W235vb2/utsD6mZNs5ihbFo6b8p+E2TlTZENgTd22Zwqom3loNRscYzPH2cTc0To8Gc1BHabETN60ebYx1WIDJ81aPdM283UcTp4xc9AANkxg5m29mbunazOcYj1Ps47TZ2a688assmPHKW77zb2wxfR3pvm0nbGTNObOmHk4BZyGM/bfc8AmYHKz6XN7/RQn2MhxNtE+1TQNOeO85s/BxBrYBrXz59lSM6t6pnXatGPOFmrnTOfh7AKsEVhzHrANTk6u5yibOX5mi5mDE3D195txnZ2dzbX/lxtE5AbgNzE7/w9U9V2x7y8CPgBstM+8TVXvEpG1mHsxnotZgR9U1V8dukGqOrIXsBN4IOG7vwJe5Px/N7A7q8yrr75a8+Cee+5ReER5liq3qZ6v39Z/r7+qX9IrVD+D6ltQfSGqz0Jb0+h+0C9g/upFqP4SqofRO/Tl+jL9uHKfKq9XU94z7Gurfb1YlU+qXqOf0d/VN+rsmZrqu20555vyW9P2/2fZem9C9S70K3q5vlXfrjv0IeX3bPm0FFp662/cY8p+vSq/Z/pws/6GfkavUf0aqm815X8Y9PdB78H8rzfZ9n8GfUpn9P36an253qG1784q74zq2G9ez1Dlzar8uSn/5XqHflxfpnoY1Q+h+lrT9t8HvQ1T1yPYOj6Ezp6p6R36cn253qF8+6zyAVveM1ThqN5661+aMfoFVb59Vl+ud+j79dV69qTpv77b1KG7TT33gN6JHa+3oPo19FP6In2j/q5p/22qXK/KVXbsxY7XVWaed+hD+lZ9uz6kO1Q/att5fu/VnYvz7Ty8Gz17Ev1dfaO+SD+lfNKWL6b8W3/7HlP29XYe7lN9mX5c79CXmzH6JVPWF+i9WtOmP/pa+/0+9DN6jd6sv6Hn67edeT5q1uhWW/47VfmMWUdv17fqV/Ry1X12ni8y4/Jf7Rzo+bb8D5n2f0av0bfrW/UK/ZJZq7/Qq+PWW/9Kadh5+YzqFfolfau+3ZT/GTsHN5l232nL/3C0F25C9aPoId2iv6E3m/L/3Lb1n9k6RHv9eKfqzOmneut0nx2D19rxvsjU84gtvzvPD6Mf15fpq/X9ytdV+Q+9vRDt5zwA9g1Lxy63eyrklVafJejfAv4RRjT4CrAr9sz7gJ+x73cBB+37nwRut++bwEFg57B9W0ovoMeAZzj/76D/3tZScN99x4CdJkD7DLRaTVo0aNM0Ut80cAyOPQQHTxuBow1smwDOBzrmdwB1Oj1p7imM5H0EEyueZgGaxvzO4thhzF1Vx3qfdZikQ505Jo3oNQVIA3jCSEvfwJyNtsIkczRp06Bl2nfaPH8hPaH72DFbR7f8uukzsNCpmw9nsb/YZjp91Hx25Ikt3d8A5pbdR834NDBGmwvtOEX9mD7miNRHJsy4HLTjA8CkaecZYHaiVzb2syjZymlod0wfTgGNaTt+YEenQ3Nd28znOswZ8gigx8x4bQFmMOMItGiasdwM7dNw8EnzesLWwxTmN3FM2fLVti3qXqf3SN39x769bKKnLjh42owbj9rv62ae56jTajWdsdkMPGH+P2r7M4NdER2atEwbTpuxWOc0sx2NWwcm4glr7MnQzPMTdBehreMEm2wNZqz4DnDYjA2YflyKXdp2nqM+N83smzqetvWo/dXpqM4YohQ+HWgfNfU8YVvWsKeSAezALDZpILLX88CKwjXAAVV9WFXngNsxqnAXSm8JbcDsvujzaRGZwEzJHGaLDIWlZAB3Aj9lvYFeAJzUkej/J81wbQV2QOvpBnPRop+mu+gemocDmLW8Ddi8nT7CUKdjCO7MvNmBR+kdfxNyU9U7lmpYRtNwnjt2DNqP2t9OQxvDmFqtpilzp2mvac2c2WjrgBnYyHHqll10yz/fPAl2U7nqDqfeLuHtblCrTIgY2BGHQUQ4DRwzq+1CDFHYCey0zJPDZhz6COIhHAa0GVhrqnqaLkMdgCVyp+adlR0xXAfNZsuoSrrzcxB4yPx/Ad1sLF3idj7mefvkQcwYAea7zXRpY4NWj7hFOINhAG677fN1Or3Pp2DzZiM8RHNx8El6ik5nnmePbDRzcGHU3stMy77TKyti8o2oPdNRGw26rYwI/xnTfrAEegrDeI6AGdE1vUw1s4ZJdoWhafMZj5qxOR8zz5dNwLZpuoJGo9PqrTvoMS0AcVsX22t1BubyCYwG7OmobzFBqbbltGnvBdi5Xho/m5xeQFtFZJ/zutkpKknt7eLtwOtE5BDmfut/Yz//CGamH8eIFLeq6jGGxMhsACLyJ8AezIAcAn4ZWAugqu/FdO5GDN1tAf9yRC0xC8tKhlu3HaVFgxNsYn4LTETSIWaLrMeR/i8AtmMWviUMtXqHhakJs1Db9BbsTEoTZuhKiA2s5Gn/NurAtCMZPt0wi34L5u+hRrcbRrlvNvdGTpjP7e/Z0tsePrGg7ds87ahFDVN21IcjE3QuqtNyf3PUjg2wfsIQOrbYuuOS5xSGMJyxfTgSdaANHU87Yr/vI7/Tvb+RpDrJXO8EcF5U/jZrX6B7SjJl2ZPeZiNlPmbruhSnD9sYZOLd8bAMcoHeyczX/tOY8+wxU13jdE+Sxqr4mXJOYrMTPeL2GHBkM/AQsNPUMWM4eB+xtXO9HocJdOz70+5jDiOO6mcb1A721tYZe9Lb1v/osWO98rdFQssWW/cZK9RERHwGQ44cBkg7hUhb20b0+2jPXQhdJjw/3RNStm47ypMzKy576RFV3T3E718LvF9VbxORHwA+JCJXYE4P5zAUaRPwv0Xk06r68DCNHaUX0GszvlfgX4+q/h7WeD9t0aBTrzExvWAMbvbz83EIQ2SQC4Vd2JPxDVi3L6uqadR7TMDdEF64BCf2XPcUYzfo+glYPx9jAL72z4ZP+/y0XSRThjE26g5R2Ew64xsSXc+LmGQYihYNM0aRQdwZi/XQk0ijV05E0nYXM+53hrY+YecczFiaNtUTTkHr+4TciJC3afTantTOpHWa0a8+Cd1t+7RVy0Sn5JiarLvGO86PQnMmz5g11Djd+2m01zr1Wr/gEdCHFYQQtfebsO7zqvr3IjKFYds/CfyNqp4FnhSRzwG7gaEYwHhEAkfryUesylhcoSfTvMKMr70pBLcR28RhSHZwa9I2euV4u1OYUuJzaRiBkNeME2eLxN4WYPSpsH1fH/HaaY+O3oXkqN9BI60tgeunzpwh5Pa79a58kDUuZRLnzLKWxhkzcgMNeWXgXuAyEblYRCaB12BU4S4eBV4KICLPwqykp+znP2Q/nwZeAPzDUB1jXBhAUWQt/jyb1pUOR3GqHaZMTz8i6XM+pFz7TCdpB+dsWx/zCvqts/3SmI5TVm5tctpOyZLOLeanGbQv+JDE5GM2gLIQPwHAEGs0a0+sOI1OeVDVeeAtwCcxbh13qOrXReQdInKTfezngZ8Wka8AfwK80WpLfgeYEZGvYxjJ/1TVrw7bpioZnMX62N/c8BCeTr3GRJ/DuQdJG2Jd7P9AabqPOCQRkpl5YKL/4an+9x3qg0dxF5529+mevcQwgHTZcoPmoYBaqK/sIGJUgNz67CIWLRo9b7IIBfrh2gEy+zEFtJ0Rja+tLDjrqFP3cMIp/F4/GRh6zy0SykwHrap3Yeyf7me/5LzfD7zQ87tZ4MdLakYX1QnAQXchhqg4pmN/Q+FKoZFdIBN+O0YwSjym55YM40worS2xsrt0ys5H5MaapN4pxBDy9CfN3uEpJ2ms+k5KfeMRQGaGsbm4uz1krIqu7cjYG4fb10hFllVmVM5KTLSzAjAGJ4CCPC6vbtXBnPvjyAAZswun6m5LQFePG9voXSm924c+q2Mypj1t9ozDgGF0mWEd1u0wDxKIZcSQ+uB4fEHPy2toLJIhNHFd+gzxGUykuS5B3VW4L0vnBro+lFLOZz+ynFCdAELgbGDvonYJ4ZTHCyiCb+H7iMNUyvf2qO3Tt4/EthBvDxQjaFkrzfXQcTdbFrHoti0fcQja0L66i0rgPmI5k/F9Qhlu2zPnPK7ucfrUt5ZjXlK5Maw3WNo851VZVQjGGJwALNIWUZL3TDDxCagj/rsE1U9zXZvZtJ0Y32ixNvQdqbPaH5U15fksFL6mRjaGGfzujgGG2nx7PoD4BxqHE5+PM7CZ+fTTzjTJAW9pcPXtKRPYIK/uPKf0HPU/aw1FQZHx3+Vo0XLX7tRqOU7s1QlgGSKAqDUYUtDIqsOzgBpZdoT4b0qQhBKJSijhDyEM8TiDaIfndHVMJQyJBu6U72ybu8MYG3evgdPX5qR5KCpBJ7R3IKArCwWN4kMjZO0keErFh7Jd96jVKowMY3ACSDagtutNpn3uC3k2cl7xJcVDJBmDhGnA4ybuxhesZ/XLkT7ik6huiEe5BqCv/LIIl4cQxdvTAL8j5lQvyjWR8Ia20wn6c+fay2D6MIQ/TB69elI0cxyB7q1dRMFgIXuijJiYRUKtlkO9mntvLy3G4wSQhqyJTfp+yHNrbn19XFr17cphCWneE0aI3jZqUy32uUU2UQyFf0KS1DRdBun0YaAtUVuH0I03htWtxxEfc0+upIG1EdXvGeq4vaoxXZ4tqfV02cqd5e4wuvJQMQDwGyDzbIIkL5HoOFvE6yEqM+ceWod/m7TSJPMcwV5Bz88UVITacQo+vXTVPctAixxnKEMy+DQ06maOS7WNJtUfSd7Wm6ldb/ayh7rw7IFEL6C8bVhq1OjexZH5WmGoGIDF+okcZCSa6LyEc8bz2TLPczKUhD5E37pzYXPEBEUke+BTSXXLztO+aBh8v8m58ftUTL6Avymo1XPq/zORk0mmjHdfgrqk3zlj0p2DmM0r2nPrJ9LrqzA6jAEDqPVx6Mm0xZuCPkKS5N0R01M2Ohk+8VmEo0scHEvkVC9PfDCczVWnY4hLUWklKsuVDB14VS4+b6M4PMblsg7885EaZiahzJB2hWCZMPO6vV3C2/ZoTdk56YtZGVH7l3tsyDhjDIzABVBEGnFT5CaV2aHfQJgEXxmNjN/EHw+JVJ6KCg5EQP2hRuA0F8ehsBjH8Kw6omCwUFfQ7lD456IV5esvYk+YSiy2i745m2KwzWl1zmAi62bt+zZ96zcxJmYlocaqPaGMwQlgCCRN+hS9RT5q74Sc5fe5sxbJcOnkou9isRa/7WuwETIygIp9uX3IQCN+khloizMGadlksxC1Md6nmfnCzKoxbea4Ab20CyFjFrrbM1x9vTaAUORIodJ3Ws8rrFQIQnUCcLCeBANkwY2a6GY6CuS9uyAv6p73ns3cPe5HYxYFg+UUNUbp7xFcdsq8l66jH4bJWATbSXx1LIEBs1E391ekGv2Xg3G1OgGsfgwswhANReimjevL44tpyqM6ySgzUqHMF1ELxLGYgpU9YfTZMBLa34DkeSgqPSd9kTSGCZ9H12Z2VVlxZhiq4RoBcfOq11KC8Bq0ktU+HtVm1wjsrtGEpG1zvtgQ39gsE/vJuGEMTgCSTkw9ftSLhiGJd6q+PYSwxF0o82SIzLJ5gNFTdJxyQ/oaIAGH6JWDdM9ZdblEMSGOoVzYuVikoKdms7V4OvrAXEcjsw0NA1e9uMowPicAz6YKWmxZCzchdXRXTxr3D/e5gpaIvjzxaVcdxscjhLAFtrl8F8YAhBCYgOlu0zTrYnYiv3TuO+nFxszLtD1jn+VDn5QLKNMIn8Vc3DaHpPIuGoFciKCufBuAiNwgIt8UkQMi8raEZ14tIvtF5Osi8r+czy8SkU+JyDfs9zuHbc8YnADCkcs/PH4JxigkQ98ROwllR5wuJaZyJOVbR4+wBM5BA7zEvS8PTZTQDrwury6T696bnAR773O73kx2icwj9RdlTFkIzUlF7GYz96Q3S7+TRAqie4GDjP5LmAqCNeXULyJrMDd7/TBwCLhXRO60l8BEz1wG/ALwQlU9LiLnO0V8EHinqv6tiMxA1m1T2RifE0AGokVY1mJMDZYpKjWNahOElOtjRk4/Eg2Q0TMJK61LdD2/D87BHoIcF9FkxljkHa8yEe9HZlS28z5tt+dkKqm3xVk0mx5ml1TPUhL4xcM1wAFVfVhV54DbgVfEnvlp4HdU9TiAqj4JICK7gAlV/Vv7+ayqDh1gMV4MIO8i84W3u4u6jNTJvvLj5XpmKXemyIJo15v502InwUMz+oLlUsZnmIhk97cDTCVW54CEnlfrkDJWmYGBRcsOEVric+SsMa/aKG9KixCbUFEsNXOIbAAhL9gqIvuc181OSRcC33H+P2Q/c3E5cLmIfE5EviAiNzifnxCRj4rI/SLya/ZEMRTGQwWUsHFSiahn0YVe9DJw8fc0/jtTi6hsMvLspNErr/923DsklDCkYKFTT1ZfxcY101W2TLVWvCxPXxJ16BEPKZMYxcvKkS67TDfZoEhdZ+yGigOA4mOYM534EuGIqu4e4vcTwGXAHmAH8FkRebb9/MXAVcCjwJ8CbwT+cJjGjtcJIAl2QXalw2E2eag07CFsfQwm5/V7IeUPDV9COE89Xf14wjimGoktUe6T1Evuy0hyz/hucfMFgGXB9n8gk6an/MIm0azLcdJOYmkSQIF9k6nmW2rpH4wNYDrwlY7HgGc4/++wn7k4BNypqmdV9RHgQQxDOAR82aqP5oGPAc8t3CeLsWYAQ6VU9kUCpxkhE3LnpNaXstf62p4UuZmVgyfpeYs+yXBYN7g8Ky0icFl1uh5VWZG9hU5b9u8QTN2F97KThPYmegEleeaE5jPKc+oJtTfE2xRqI4naVZIH1wrAvcBlInKxiEwCrwHujD3zMYz0j4hsxah+Hra/3Sgi59nnfgjYz5AYawbQh4BFOFdE+slBeLzlj0ACGiAuMa+NTDfOPJvRwxSjIKouFsN7yV7UkXrpeRbyeHr5Iqcd9I2xSwzLhKsunCZ7t+cw0DZpm+fL9H5bLV5sCbCS+1uATwLfAO5Q1a+LyDtE5Cb72CeBoyKyH7gH+I+qelRVzwG3AHeLyNcwCrHfH7ZNq98GEC16u7ibcX1n2qKzkmXk4TJgA8i7aaNEcFGysFBCmoNNr5+g/15S2/YBvW0e6SsJeZlTXP/vSp4BYxEcJJT3PoK0Yov0MYV/BgXvheQywlGf2PZHxu48t60lCjUp11SmerjF+jAZEPGdiaVOBVFiIJiq3gXcFfvsl5z3CvycfcV/+7fAc8ppiUF1AgD/wszMoukgSwoKDKApNSpzFNJUndHqZB2due/GrkwEtq2RIZ17MexOWebSbdeNt0hKFMjcA93y415XRV2iK5SC1X8CgPAAoYgAlcTtjcSanQwuOImXZwN06jUmWPC3Oavc0OO7r5x6//edei3ZNzzWtkwVU0hMRhSolUL0+7yx4vNaNHCuTn47UR7kjcgOiXBPaYdX6EgRWEpJ1VDWXCwWaiwPY/QIUJ0AIhT01si9H4ou9KUMPkqD0/8+gruYOZYaBLvEhKaaHtDRZ8EtN2+wVijKKGcd4TaHUe+JjPIH1LUVSsfqPwG4LK5rB0jPs5KEVCNw1qJ3YwHcg4GzCbrlD+HymetIHUdaCP80cHSwvgj1TsIpJELMFgMl3BTlGyfns5Bo1dzlW3i9dCIbTygiQhyp1hKC0nx+97mjpBsUF/di7RpoT9hBNxih+ZIWDZEb6CrESE8AWYmPbHKje2xk21dF5MZRtqd0xIllmTlaZjCLvs7ALDVpZ0cCh6RpgN6FIkUYR0K5fcTR7WORG80cePuc0u4kRp92ChhgSimpOFIFiWEIxkxCGoVYuY24GqUA+oSatFNMElIijAfK96BvLqahHWfavviKCqVhZCeAkMRHwH/GuEL9rs11cRewcyQNCkxONVK4HiKx9gTpVmd6qomB5xdjc6QwirypGkZyT2weJhaF7petf46f9ByEznEmSlKtTTI3aANI8+kvywgb6BSxbFClgy6EkMRHSi+qfQNweCQtyaMbTyAIwRGQcRfEKYpJVnGE/M73TOGLUzIIdJ4x9Rzf2zR7qZcjRMZBN7gpRF89k6M9KUFxHTyXl0RI2SlBzG9I4pl5iltqhI6/m2MoJZq8wuJAjNvpCAoWeRVwg6q+2f7/euD5qvoW55kLgE8BmzDL4HpVvc9T1s3AzQDbtm27+vbbbw9uxxNPznKoNdMlElNTbaaZZR1Ps56nWduahxPASWAOmKSnl53qvU7W1nOSDZxkA3NH63AMk4x1AqMjFPv+PFg/aZ7cxHHWnpo3F2XP2+fP2VeUyHUTsDlW/mzdXEZyBmjDjg2zHDo5Y57duMDMxGnWc4p1PE1TT1M7jdE9z5qXLoA06amRZqBVazDLjPnVwjoWTk30+u30kwbQXGDDRK8PEycW4LjtQ82+JuxfMWO2sAVOygaOs4mTCxtYeGrCtF9Nf3dsmOXQUzOwGdjSK38jJ1l7Zt482zH9pUPvGsmNwAaYX1/jaTtrs8zQnmv2LiOPJO6IEayD6clZZpjtzvXEqQXT1xN27KM5bvTm+uzUBCfsHJyc3wBHa2aeJ2DHplkOzc6Yfk9BbfM8G2pmfDboSWpH7fpRW3403wvAWjPHZ9fHym/VTH/POK8Nps8TG+dYZ3s8TYvmQhtO9eY5ygMp6+naDxamoSXTPM06TrGe2flpOFEzczcHO7bNcujMTHeuJ2c6UWvYsHDK9PW4HcuaXddrnPlumD4cZxMn2cCpMxuMXWi+N89Y5yy2wOTGWPluP6M5jvac7XenOWlX9jraNDlzpmHm96Tp9zMvmWVmJlz6uO666+4bMjcPu3eI7vu3Yc/KWxm6vsXEUhuBXwu8X1VvE5EfAD4kIleoal+ea1V9H/A+gN27d+uePXuCK7jtv+/llnv3wIuAXXD5rq9yLZ9nD/fw/XyeS+87BF/EKJ8eBS7CZN6IXt8L85fBXetfxue4kbt4Loc+ein8NXAE2EpPNXIe8Dp42a47uZHP8UL+nAv/+ij8A2bjHsMs5o59D/DjMP+yWPmfvdSchf4B+BrcetNebrlzD/w41F58mmu3fZ7r+RzX8jme3/k8019cMEHhnwO+AO3T0LgSeCnwApjfDfevv4KHuJbPcy17uZonP3oR/B2wF6N0eybwLOAKqD37ND+67S5u5DNcx0fY+hez8FngcdvPzfSMlpuB7XD62hp31X+UT/JK7mq9hNkPbzXtP2L6fOuP7OWW398Dr4Panl751/KXXPjAUXgI+DYmPvIhejkTbwJuhCN7ZriH6/gcL+XLXMW+J65m4ZPT8H9svwFeCLwYai86ze5t93El3+J67uZK7mHrX8/Cl+gF3j/Dzu+z7N8d8NgVW/hLXs5d3Mgnnng+C388DR8GtsCtr9nLLZ/ZY+b7+2DmxiO8qvkRbuQunt/5BNMfXjDE8Jid66P2bwe4AHg1PLYnVv5XpuEARkH6NeCbmCQAPwbn73mUPdzDdXyGnezjqlMPMGHnl/8D7S9bleULbL9fAKefX+O++m4e4Fru4To+/cTzWfj4NPwZ8Bjc+vN7ueVbe8x8fx/s+MED3Mgn+FHu4kWnPsXEnwF/bsfHN8/PNn34CK/kLn6UTz36InjvBDxl+znr7InXwY49sfIfcuY3ekV77kYz1weu3sGnuZ572MOXuYwH9z/HzPH/MWv1ng/uJc/+r5COUaqAQhIfvQm4A0BV/x4jm2wdYZv60Igb8RKO6YlHfFflEqk58kShhqh11tE3S/E0Cu1603+EzqOiibWjua5Ng9bgBe8BSDWMlu2mGi9vneezAmjQMobsuGopbb6KBlDlbW9KMF673qTDZLatIa8LaKy4gUjgdX1f5kMV3LWkGCUDCEl89ChGTkVEnoVZDk+NsE3ZcHXQeTGQ6iDm0eDbVGl1eTZHYhDVsBspwc2uj5g4kbrd/7MQfyaL4LlENyTLYnQjmO/uBh8zcpPGjSJuIu6ZkzBGicneBgzHAamX43amECT1Pe/6DxxDrxCVsgeKumqPBDX61aRprxWGkTGAwMRHPw/8tIh8BfgT4I06KqOEB30EOiN4J1WqGtJDwLs50nzQkzbHtPldYW+mtFw9gfD63sfdJ5OI36g3kG9cPHV6+z301RthdYeiO8dlJrELiCZv0/Azpbx7YJV61aw0jNQGEJD4aD9Ggzk61PCG7/dt8oBNlOh3HyIBTdELEEpIFtbHYHxljiIQxqdOsOOUSfxH7bmxnDxDEsY+MdDMdQUdJfIwkIxnuylFXIzCBRTy595aatRY3u0bAuOVCiJLPx+f5NRcNIF1ZuXR6X6UEtjliaLNhOPjnummGMJcZhLex5B4OimaingUiM+Jp+6BC1kSng2KNg5dKzOxv2XAbW/CKSY4v8+0x27mIqH9A66+sTK78DVjZr4/WrpCqRgvBuBDlo7alwQreiaPVF5U6hnVos8TxZymbvDon7tRrPEyk+hMvNz64OelJCHLga6aKiC2onvRS0rUcGmJ+YZF1nryZQV12t6mkZ4OOq0fSXttuRP2SIsQ8lphGDsGkJhyOVDCTUTeW41GdaScDmxLBhIDwZIIQ/y2q6gNeQlbEjPIQihh8xE4X70+OH0ZSNWQdNLzfJ6abiILkWF5lCemjLGIbABdhwRfW0KM/WOIrPQ4znOvFBEVkd2xzy8SkVkRuaWM9ix1HMDqQEQYimxKu9m8Em4RF8ElRMs6jw7AbZcdo1JTQUTjNEQSPRfetnkuJE/0MspzrUNe4h//v8icpyX8iyOl/IVO3bR/FrMHSrzOAkq+H2MYlGQDCEyPg4isA/4dJkIpjl/HRCGVgtV/AihwF+1Q1QXmus+Eu0mdfOSJHjQZSDTqTiW8z0IKYWi18nsPDSAp0Vxg7IYXHtVS0MU/eW0eRRnxFF1hYjKmZsmbawmctVLU5XUxDJ+r1LiagJD0OAC/ArwbEyvdhYj8GPAI8PWyGrT6GQAU06+GEpYEg26fnjS+yGe6DwIJl4XnRShRwyEu3eC1csv3ZrKMGSAjhtTniltU/VMSBuI2ysKobT2hRDR2iknNt5/XhgHh9wFkpPHO9bvFgJAnDmCriOxzXjc7JV1IL8YdzCngwr6qRJ4LPENVPxH7fAZ4K/BfyutYpQIycBeWZ/F6CXTGIs8M4Aklbu5zeZPaFUFaHXk9MWbol2GGuYEsqfyQz1zUMaqKDIbWbLaMJ2e8zXm8v2ZJn+eksrIIXZ4MpoF1tOtNppntjU9SvQ5q9Q4LcRJSJAI9NCJ+ZeBI0VxAIlLDqHje6Pn67cB/U9VZEY8+siDGhwGEEIY4ypA4ok3jxgKkoEmr2GXzbn1RPQXb70rwmVJxQaPzgJ59mGyXnlQWLhKv5iyatsBZS634CcZleDP91bpj2WUwsfJyoUiW2bzOCqG/8cA9YXQZTEZZrQLBhyNHeRfCZKXHWQdcAey1RP57gDtt4OzzgVeJyHswKRIXROSMqv72MA1a/QwgRck1sNh8OuIYEo/NoWqUUdq1ihCSYVzxQtIvTGGydrrPJF12AoNSYZItYF2b2fiXaX0oQiyLIJDR50Gf/SY+5nnTMOdFqPrqTOyzkFMMhHnGrR6PoW56HAzhfw3wk9GXqnoSJxeaiOwFblHVfcCLnc/fDswOS/xhXGwAFpkG2gB4JZQAY2EXeaSr6Lu0XPS+nZ1DXx+EHDEMXi8g9/ieV4VUxjMRQgy+SUgIouoyvDJOi1Ff4sQ0EImxEkWJv+d3iRJ63gRzeb6LsMIZQWB6nEXF6j8BwHCbcxQBPJF+eIiMnaU+Hz2bpf9PKXuA+MTLSlNbRvOTRyecVVYSIrVMSF0zyc/EvXT6ED/pJcQDeBGaVKwIY4+YWIhdII+NIWJYkSto1p5wYzKO5qhrqVBiKois9Dixz/ckfP72clozZicAL+IZJzOSbHV19NF9vSHwhriHNzFXHXl0wXkZY5QbvihGJcGtY3RGwow2J6aCCGGq7vch8xZXm5TBMH3t8bV5mLVeYdliPE4AoSiZQLXiCefyHO2LpJuIYzEkq7gB1rUBREFCRRCaZC8BqUFEw8xz3sCtku0BSwLPOkrNXZUHGXPR9TRaylTL1Z3AKxhRD4uoW8omoEUXcegsJaQ5SI0ziJ4d1QbLmzQvbqy1icDaTpRxaRGieVIqQ19f5hw33676a1gikecUEP9/VLmGRuWfX2SsVikRXkpUJ4Cy4GyCgUtUXOTxBBpGUs2jWnBRJDWBQ3y8KpFRSm8ZkcwtGsb90mEmufnHOtJtGC7ynPSmYn/zoCgxHMZo7nG37Xpi+TyBQspcCajSQa9iREShqD51ir5cNM117ezjcZETRtp1h245eVIPB6iZWjQHjZgpvv+J6aDXUF5itxxIbI9761gaEuw3A0Zgt5z42NicPUE+7inXPQ48E9KHGfzzm5UavQiDycvQQvfcCvf+Wc4YjxNAEV9p573XvW5YqTbt6D4zT3dqYvUk+tCPSELpi3sITD42yVzwmA/YSSLkIUCjSppXcnqG1NQLRV1lY3BjBvqCzSDsFJN3HcXtPCHpRXz7bDmrd6IrIVchVv8JINbDAYkw69haZjRwSYhOGAMJ3kI9T5KwGJJW/HrIMrOCRmWmBZqlYEBCX4xbvdzxcNNN+8YlB5FMPYUmrelh/fSzkLWX4sKOu1erU8BIMB4nAIvgTJqjkKajzVswyCcJhROYRcQtwziYqbbIUj94+htXn8xPOwuxiC96HiR45sx7T2Kx/6c8n5WBhDJTM416bDypayGj3YnpMmJ15IFrrB8ov8jcLlE+IK0lrI9VgNV/AshCYGh9n3GzSBKypPpCnltDut++L5ldlrompb2pQU4RQnPRD5v7JSHxWVEpvw+etiUm8Qu5FD4HkUgcY6dNqXcOQ7H8P877TG8qz21vXhQ1LK+UG8FWMcbnBBASIVrEu3AmoOw4YpvKtTEs2SUYWZswMpZH7/OWLYRfFxia7TIvI3btLqHEeh3F7hxwTz7296nMblhVY4hwEAJfttTQ+iMBfzGy1i4itJbnPoaFkbalbIwHA0jYBJkpm53FGR3HuwR6MaSWokQhQzLs6peLuCHmyAu0KJgh1fYRdGl7n9eukcyDTkFpWI5GwzXAuYDnktZP1jznjfnwfBbfk811bWanVgCXWKFY/SqgIkf30KNvHL4NkFWO/T6RUA2rWpo2J4xEZlcSIyvlMpV4H8r0DElSmxQh1L7fFFovMVfM2NWWiS6ssHy8ZkYgCHnX6qjsL2OO8TgBlI0UouHVTUfPF9Xu5AlCioycWQnIkvqQ5R+egtS0xR5knsBGjcR8TykZPj2fBTG/BAl3KETzXSTHv4Ou8JG0XhLqGHAzzSrfhcfYv1wNrQtSy3Fr32K4jpWH1X8CyMC8qxd2/w6BxAvPfQFVDBKQMtJWD4s+6bNoGmWf1FYkT3xZcH3OQwiiC8ErgSbetVwiBphGCWMTtMZCDf1FkVB+fVj1W4VgVCcAF57FOJ+looEBQ3BEFBKlvRgRbPiO+nFiM2rDWlZ20HiKg7wpjiNPphBkpJ72YlQuggmqh8iO0sfsfSe9mMF5gLjFxz1hnjvUYXq2uGryqew6gF75eexm0bMew7eLPnffFQRFku9aGEB1Alg9CAlRX2Rj39DGSR/yGE9T7CMRMQwN7sqU9PquXky4iCdKze38Hx+jkBQMkZdHKSqaiDnmWRuuMTsEAYxgYK0knGJSbQ15EDHLtH4vF9vFEkFEbhCRb4rIARF5m+f7nxOR/SLyVRG5W0S+135+pYj8vYh83X73E2W0ZyUy5Hwoen9yn0SfoMMsMajLuwnznAIigpM32VnChsxFFApsarf8Tr3GxHQ+97nCjDB2Ty+wqF5MpdoAQsa9jLTiZSPDtjIwRlHeqiViHgvUSnFyEJE1wO8APwwcAu4VkTtVdb/z2P3AblVticjPAO8BfgJoAT+lqg+JyHbgPhH5pKqeGKZN43ECCPFxj5BHtZFST1c3XIZ/d4Ynk9d4FjGEtPqXyKsi8YTg6oTdtpVxyvKpWWJzHUyc7e/7YjYCiFNe4h/kwjrk2ORi9LauPrtH4BoaIKDuXPdFMy/DS+HLwzXAAVV9WFXngNuBV7gPqOo9qhptkC9gLo5HVR9U1Yfs+8PAk8B5wzZo9Z8AIjgL1RtsVadUgtiIJ1FzEaUi8OS6T0SRYKSCKCU/T9JYhozxNHDMeV8AXsLmMcDnRtE1UqaqMOlOgFHVXdQtOgSx8Yw7UIR6Go0SC9TCMrkabBWRfc7/71PV99n3FwLfcb47BDw/paw3AX8d/1BErgEmgW+FNioJI2UAInID8JsYGfYPVPVdnmdeDbwdUOArqvqTo2pPKekDykCJmynHwgQK6nsj1VJESFwdt9OXAenN3dwx/XOLBh0m06XiPOM0CltMpHpIMGLPxTmt7y4AN4LaokmbJq3ebVceTNLxz5U7Bw6KulC2rPDRd2cC9CR0T7mJXm4VAI6o6u5hCxGR1wG7gZfEPr8A+BDwBlUdOux4ZAwgRN8lIpcBvwC8UFWPi8j5pTckpj6ZpMNcWmBUKNw8JjFPkSXdID4ddwyTdHopp6NUB5bYRe6BiQR6WOY1m59pxTFAGPNGMqdc01hnrkugCyHelqiuM6bsAcO3y2S6c5EQi5GRt6qIMFCKAXgYj7UUDJzUl8iOsYCUZbt5DHiG8/8O+1kfROR64BeBl6hqx/l8PfAJ4BdV9QtlNGiUNoBMfRfw08DvqOpxAFV9coTt6SJaWG2axvsjrhqIJJ8YsetumJRgqdK8dByiXNiQHVJHSQgmPsOkC1hmyJW3acixTjRC5nXFtczGzYyblwmMWk/v9Q5bjqk18uNe4DIRuVhEJoHXAHe6D4jIVcDvATe59NA+/xfAB1X1I2U1SFS1rLL6CxZ5FXCDqr7Z/v964Pmq+hbnmY8BDwIvxCzPt6vq33jKuhm4GWDbtm1X33777cHteOLYLId0Bhow0Zxjig4N2kxxhiYtmnqa2mmMpBbdw7IWo2GbhIW1cFYmmWWa08zQosnpuRk4hcmrsgZDoNcANZhc32GaWWY4zQyzNM+2jVfOgucFsB46U73yZ5mhszDJwtwEzAFzsKM2y6GzM7ABJqc6NGgxTYsmLSaZo7FwxvgInIHuXo6O8w04u3aCM0x1bQ0tpmnPNeFp+/xa+/wkMLnA1ITpQ5N2rw9P2/GpeV6T0J6csn0w/TjTapj2nwMUdqyZ5VBnBtbDVNO0JBqjKW1TO0u3v5y1dUGXEbfXTllVRZM2Dc4wxdyZuunzaefZKTNGU5yxio2W+cXZM+a56Flnjpkw83xGGswyQ4tGrw+nzPzumJzl0MKMmedJaDRbzDDbnev6mTnTZt88TwDroLW2wWmavTGar8NczfS5Y/vdMM82Jls0OW1722aSOepn58x8ncHM9xr7fNP0u12bYo5Jer9sMteqd+duR3OWQ2tmYBJqk/M0ame6fWjSNn04ZcfHN891mF1rehzN9fypSdNHO8/dPbHe9KFvjBbmenM878zzhJ27JrRqvTEys1hnvjVp+t2GZ26cZWYm/Ihx3XXX3TesSuZZuxv6wX2XBj17jTyQWp+I3Aj8BmaU/khV3yki7wD2qeqdIvJp4NnA4/Ynj6rqTVYl9D+BrzvFvVFVv5y7Qw6W2gg8AVwG7MEchz4rIs+OuzZZI8r7AHbv3q179uwJruC2D+/lloU9cDGc/9xHuZxvsouH2cV+ruLLXN3Zx/QXF2A/xvC4GdgObAWeAae313i8vp3PcS2f51q+zFV86dFr4W8mjKrFVQFthh0/eIBru09/nuc9/gA8hCE80cZ1BcfnwYGLd/SVv7+1i9mDW43i7Ltw6/Rebjm9B54NO3Yd4Cru52q+xlXcz4UcZNepB5l4CPiyfWFH9TLgCjhwwQ4eYScPs4svcxX72MkDj14FeyfM8zuAncD3QO3C01y67Vtcy+e5kvt7fbjbaXd0Qlpr/z4Dvnrx5Xyea/kiz+fzPJMH/+9z4GCv37du2MstD++BG+Dy5361r/xdnf1MH14w4/8o8ARw2Nb1fNOHr15wOfdzpRkfdrGfSzi0/1L4B3pbYjewa54dFx1kF/vZxUGu5H4u48s85/EHjU/F1+yz20272Wben95cY399Fw/ZOej24ctmfm+9aC+3tPaYef4euOK593ItD3Etn+f7+TyXPnDItD8+z6ftmvoBuPeCK3iU3d0xOvDEJSw8Nm3G6THMfF8JPG+eKy66n908ypXczy72czEHufTxQ6Y9BzFrCvv8xTB/GexffzkH2cmDXMV9XM39XMKh/3upKfcg3PrcvdwyvQd2wMzOI+xq7udaHuBK7ufZUR++aNvsnoSjeb4MPnvBNXyLK+3qfjaHPnspHHH6He2Ja+a55qLPc6UzRhd0Dpt5/o6d58POnnsBnH5+jfvqu3mUXdzPlexnFw/yTJ78vxfBA2Zt33PTXvLs/zKg1Eo79ajqXcBdsc9+yXl/fcLvPgx8uJRGOBilCihE33UIuFNVz6rqI5jTwGWltiJSnyzlEdLN2TJMeH3MwOiNTizD08WHohGoKUbUCO160/+da5T0lj/fX08IEsY+MddLxNwjI3ZSoFNaHp0QV9PQoMK885tRptf7zCX+0Zq1dS2Gfatjzju9D1aH+mdZYpQMIFPfBXwMI/0jIluBy4GHR9imoZF5MUyhMkenU428QxIlmIRUB4luqQmEAQxxmLSm45D89KE5X+an8/nQJxpwAwlJkP+9D0UYfcL4F8WAUBAJDSG2pAyGMj+NVcE1/R5fIZHAw2CJGMECta5DRNZrpWFkDEBV54G3AJ8EvgHcoapfF5F3iMhN9rFPAkdFZD9wD/AfVfXoqNqUirirowOXQA9kinSNtR6UkuEw8mTK2gDubWCeelOPsbH2u4bBUWVpTN0woXcauO0e8hRQFCEMPHgM8xrJs/oSXzMJa2goIaQIA3Mj1z1xBkt2MdKYYaQ2gAB9lwI/Z1+jQ9YCzRtYE4hMvWGBKxV90m2nXmOiyE1EeTN1ZqAUPWlEDEoWAwYSkaXMcWo66BiG6XNzXZvZowUWm+cnvhurSgnoS0BeVVAfgxnB/I4SCyXaAJYbxiMVhEUuF81RuiGGqAdm5vsJUChxHjYK2HEPLFL2QHDUMChpDvpOGm6Zi6FSKDAcSamaB04RRe4Ehj435gEX0IxU2RBG/MtKad7ds9VlMCPBUnsBjR6R+qTIRSdT/cbBaLMkRnD6cgHB4IZKSCIX6o/tbsAucfNt2hACmndj+coMIaQJmSj7UJR3OPXnJjwJdfZd/RkZsWNCYKnMLmYLcNdCOy49x+FpRl4JfeC0ELfzFOzqUEF7cSwRE8iXDnplYaxOAJlI0J0nomQDXoSBlBWR8S6LiSXohX363T5CGduUXv1r/DQSQhgy7COQokKZjv31IITYe4lnrMxcNo4A43b3/5Tc+n1j7EtUlwXX3mPhtalEayauSiwrLYpPjZhnT6yAgL/VjNV/AgiFm8clREpxUy4M4/mQ9bsZTMBMXpQgsOS5mWlYD4j5aZgoohfOUJNFkvCAncQzPsF63iRG7JaZkG6i6G1XrbQTZShSssoWMQJ3Tw3uuDtpSOKCRLveZNp9INpz073vlyNMMrgS7rxehhiPE0CaBDriReczznUxCuknT5kZKZeHIuqp6TIyJPeIwI1CR++W2Sc9e6hqxokrr6dKm2b5dwKXiYzxTl3LHqSqyPLM7RD3VFdIx+o/AYTk0fGtU89nIVKA96rAOBJd8YpJGQOSVQb69LJ96ofBjRblS5pgIZXgRJJtJlH01GGIr22/x0MkIjyL7okxW8L2yCLSM/NwxNYzBMNLFWRmMNG60fs0LIZKJnC/9WEJjcCVF9AqxYA0NkqvkIQEcxG8C6yIjzv9dfiktgFGE5qjH4Ybo6zfZnjoJDLVPJHAIe3oljvf02kvg53SN5cBEcF9zNgZH9d2UuTqz1AEnZDyrKcqIrh0LINlvbhI9LTx3E7kIpNAQ/ICzdhImWqBjBvBFh0eRub2YWCMZyjeh+VkJHTmN9Vjy40Itv9nqk8SGNjAuouvzyGIYnTnQKp0m9cDyDLjVHfiCBl7rsLoMXYMII40965U75CZ2N+CiNcRSU253RkjguMQnSL3/ebyDrGnmsRxKmocD/AAKgSf1Jy3Ds989zHwHMQsaawziWeO01jfOkrY7Q1a2UJI0jjFI+IzMKqo8lFC7X0AVSqIlYopsxF8kZF13zE1Qbpt0jZSU3yDehZ/kM7Q2cBR2uIBxMotK0R+oA9LHGgTYmCMxtQ7Zw4m6XSfGZiHwCjavJjP60LsIsMYPwwWOmEcqc6c6UOR6OeiqSBi6MQuahrqYp4KQVj9RuA8qoeERRkhr5E2USKI1RPkGjiT41QQSkTy+myPOpka9IzAsTGKE50kRuiTnhOZQEGCXat3wvuYy9tl8KNEu8eQbsduVPyAd1JK2UWk3Kj8PmN/hMB4j4WpiSUTUioj8DghY0Hmjf4c8M4IIDp5bxUbOkrRbqxUBhNINKPxGSirRuENnOnhEqm+RuHum2BgznWLVkgwm6eOSTpDE55avVNMFec50RQZwyBGuQLVQkUhIjeIyDdF5ICIvM3zfV1E/tR+/0UR2el89wv282+KyD8poz1jzwA61HNFACd5VmQiRSefKFVFmzbElTWenrkkVUKHST8T8/Slw6T/MvOiqRoy8tIEGRrj5cXbZP/6rlwM0Z8nIram2vX8MQCZwsZSuWymIY9H2Qoh/CYddD3olQbnnvQfAXYBrxWRXbHH3gQcV9VLgf8GvNv+dhcmpf4/Bm4A/octbyhkLmsR+TcismnYilYU7MKM64a9/vMhhHaEWSWzPDiKSG1uP1PVUyGqrACC0CW+eca0KIY5LA2Zbtodn8KXscf19IF6e6C4uBdah2f+Srl0fvUg5J70VwAfsO8/ArxURMR+fruqduzlWQdseUMhZElsA+4VkTvs8WVUV5SPBnlaW5Q4dD2C5sONtBmnjq50O4wXjUVP/zokEhLBJRpRE9oeRBRG6RoYUHZiG/PEMvj+TyvTqrGaTediHYuBk9jAHNeDhYj4yanPzpBDKp+k038rWwL6khdGayX0PoNlAEXszczZL2CriOxzXjc7RV2IuRAzwiH7Gb5n7J0qJ4Etgb/NjUwGoKr/GXNN4x8CbwQeEpH/T0QuGbbyRUOoX3IgvO57MaknNRI4IVArr/G0iLE1IizNZqtfN1zCXQCZKg6HSPjyxADFCELeQLAERO0vrObLSqUQG59QW08e5h1fE8117WIJ2lIYwYDHmqffpSWbizDKm8bKxRFV3e283rfUDUpD0KHQXtzyXfuaBzYBHxGR94ywbYuCNo1+//lRqyHSdNpJUmfKfbqJ5Rc0Yk9mpXQoWW9bqu903jkrmE/fJ0x4T0F5pNwi6y3z1jSfW3GOvDrD3i1h6x84meTca2UKb0VQlg2AsHvSu8+IyASwAeMXF/Lb3AixAfw7EbkPeA/wOeDZqvozwNXAK4dtwIpGysL1HsfzpIGAgc2athG8fuh53EGzUE94Hwq70qI+pDKiPEbCIt4tsbLjdpKobX3jHdspwQntykY8RUNaIF5OpDIxB6mqplFlxV0duJfse9LvBN5g378K+DsrgN8JvMZ6CV2M0cp8adgGhcQBbAb+uap+2/1QVRdE5J8O24DFROam9UhsPu+QPoQeracYvAjG1pf38o5MlEB8IiIYGstgqnWMnNF1h9HGPpVdZ19K6AAm0Gy2BlLgpaoehvU+cYiUy8C8cQYJ6aDjKHwtZIkMJtN2EJw7CePmb/dEXB3VpsFGjpt/PCfVzL22RCgrHbSqzotIdE/6GuCPonvSgX2qeidG1f4hETkAHMMwCexzdwD7MVqYf62q54ZtUyYDUNVfTvnuG8M2YOQoIY9OYh6ghASc7mLpUGd+epaJOEFII2y0OMHGXj3HcjQ2hvixdIAJurdQORKvl1kWPWF4sFwu/U6TnltPezZ9lgolzug95Sf2fdSBTo6AnxhhmzAe89MZQZE+AacAUgP+VsG1kAH3pJ8Bfjzht+8E3llme8Y+DmAARaRDSwiDfdzz2gHyzFKe9pdw7PYR0N51ijFiGVJfRjS2FyUZgePoGlBT4J6QSlHFJJwyTF2xcciQnvuIdEYwW2bSuQSErvmofK8n0yhUfRWCMB4MoCDhieuGU4+Bnou289gB4hhQZcz0l52JjHoGPFBSJNs+wuO7SSsk1sBZaXEJOPE2qoKb3jdG3T4kXAgTtSEo6yuBJxhnrFKZWN4LT9y5DREmijLHUP1/CRe2LOckcYowRz3otdIwHgwgAWm6T9+CNMmpHOKSd2N5CFq73hw63L8r/WV4ACUiT/RmkfJjCIpwzfIM6RI3h/iEEqKUXPeJ9piMnZKa8iNkvPpcZAMu1xliDpLsJHmCBhMFkYSL7V0sZ2I/blj9yeAi7xO76H2ZJOen7UAESpx90nPKb1xiMj/NoB0ggw7W6h0WnCmK+pA3utLHYOYi1UWM+AdnXyz5Ig9vojDnt8O4i3Z/m9COTDtJCrzRz4H68D5bD5SqxorWSNxQnjvNeN55PmP+BuezSik/2qvdPixhMrjqTuBxwhA6yWDiXNAHPY6IuHVd+Jznh5G05nyRpbE2p5XflTLjrqw2yrUMdImMG8eRE0lRzN1gORe2L7nvTHDQptl3AhoqYGoUenFP/qWgdTSMGsu+T1XDVRgJVv8JIANd/XPkuleEaGYs/k69Rr2z0Psgh5sgYNh0SZs9Ij4+CS0iRm4aglI3Y4YE1717OIKdi1LdA92xDxnTWJtdCdrH7L0nPQt3LF0mGD/ppaF7Ws2DiEHm4TXxVBP1Wvlumgn7wKuGm5lnqchVlQ56pWMII1WigTKGWn3wopi2TQrRh1F6M7iZQENOGM64+FQD0Ubs64OHMHTfx9Q0udUN0H+jWQLS4iaCVQ957HUJcxZXCwycJhK8dFJPQAlrtY8A1fvbVMaFNkXQpE1zXTt4ntP20lL1YdwxVieATPWMJ8FWKlaAa1qcAXmJT4gdY4pUyTlTR5+wv72SVZ3gE5IrPbuEKM4k0phYalsykJrK+4zz3rYp9IKXIt5eeewkpV/YHvibAVvPCjAImyshV56HTwhWP9sNIDwD0kdahsshMB/Xe077mcxQOvKADZWVyCtv2dl++gFS7bBISTQXIUSXndimlOVQWrZVOxdJhviB02Smq+/gODTXtdNPSbEyc9mRuplBs1WihbACBK6VhrE6AaQikjoTLjoZwMw8zE4Eq5cG7ACx8otmisyqM8JAlsgh00+EEoZaveO9lzbIZzo0z02KbWFg7gLsL0ltC1V19NkBlljC7a6jGcIjdVPUfKFo0kq/uzlSUybsueWEyguowpJkrWyuaxsGkzFLA7rVjHS+EQrp6B3kJgxOv+O57pcambeyLRKy5mQgn75Fqq0qVEhxKXHOfg+7lpJQXSgzWoyUAWTdf+k890oRURHZPYp21OqdAYnaq4tNIZr9tzn1/zZr8bsBNkkSbebF8DPzTDKXqN4ofOdtBhJT+WZgkrlcaXzbNGjXm72spgXUGzA4N95xteXPT0eBeBl2EjfKO0OF0scUY2NVmsorNjZF5z5VQqd/rRapw2UoeZIKxlHGaXgYLFCrIoHzIvD+S0RkHfDvgC+OpCF5jI95ESMMpV+CkRcpEa6JmAFm5ruELUR/nkUY0vIZuZs5TxbUoAtnSoDbpjTC4+tjEqPvG6+YK2iXUc7M5w90CoiYTkMQgc5As9nqZ/TOnshiMEnw7c3u5fYVSsUoTwAh918C/Arm4uMScgnmg7nEwXPpuffZYhuklWRsTgheKrppFgUBxCbkyJ4nWK5TryWqN7LsGKWOZW3QfhPUjxJUSKPWP/et7di6TFPz5XVW6DA5eNLzoPT06BUSIeaugREULPIq4AZVfbP9//XA81X1Lc4zzwV+UVVfKSJ7gVtUdZ+nrJuBmwG2bdt29e233x7cjidOzXKo2WRy4ixrOcsEZ5miwwTz1DlD3Uq9E3MLJsv2hHnN12qcY4JzrOEca2jTYM4u4DkmOTNnN6UlDLXaArXaAnXmmKLNFB3qnGGKDmuZo6b2OQWcLN5n105whinOUKdj/85R5xxrWECYn59gR6vFoakZJieNxBi1e4KzTGL6NUmHibMLcNYWPAELa+GsGLl+zj41Zz1W5pjkzHwd5mowAbWJeSZqUW/P0aDd36qFuV6718CCvWt5Qcw4uWPTpsEZpphfWMPCgiEgO1otDk3OMDnVifW2w1rO2nrnmViw8zAP1GChDh2Z6mt31Jd5JphbWMvCnHUDnZxnsnaWCeZZaw/lk3SYspL2Wp2j1gEW/PN8lrXOrJm/c2fqUIMdnac51JimVltgonaOKc7QwJyaorESFvzzvAbatamBMYpGe35hDQvzE6bPkwtMTUTzbNtt+7KWs6YPZ+34AKyF+bW13njYpzu253NMMjdXhwXYMTfL4Zmp7jy7YxP1Ye1Zx14Qm+do/fTPc52FhVp3nlmoQc30oX8kO921NTDPEzA/Wetbn2eYYo61zJteMze/FuZqPHNhlpmZ8KPAddddd5+qDqVabux+ll6674NBzz4g1wxd32JiybyARKQG/DrmnuFU2Hs13wewe/du3bNnT3A9t921l//07OexfdvjbOcw23iCSzho/36LHTzCxRxk6yOz3Ujg+S1wYv0MJ9jIcTZygo08zC4OcjH72cVBLuTAE5ew0Kl39f+RCuhyvsmlHOKZfJNL+BYX8k22cxiARqfV9QSKvEQOXLCDR9jJY1zKN3km3+ISHmEHc9Q5wUaOPLGF99x/L//p+00fdvIIl/IYO20ftnOY8zjMdh7nwsePYquC7XDkghkOs50nOJ9jbOdxtvMIOznIxb0+PDYNW+eZ2XqCjU3T4+08zk4eZxf7uZiDXMBBdp16kInTPXVGp17rnpxOsJFH2Nk3Rvu5hBOtjYDJq/+er9zLLd/3InZcdJBd7Gcnj3Mx5v15HGYTJ9jICRqdFtPHFswleMDpy2p8q34pB9nJ47bth7mAw2znSbZxuLWd2YNbAZjZeYTtzcOczxNs5xgXc5CdHOQSDrCNJ7mkc4Dph6wk75nnx9nOw+zqjtF+LuHQozsBuPXBz/L2a58DwMbmCXbZlbCTR7rjFLUfoN5Z6M7x/DTsX3+5bU2v/MOcxwk2caK1kdkjG+HIBDPfZ/qw0/bYjP9hzuMg2znMBZ3DTB9e6N0R4Znng7bnB7iEg1xs+jA7wa2H/473/NClTDLHRo5zMQe5JNaHSx8/1G1zfJ4Ps73bh2/yTA5wCQ/yTFqtZvfuhGhPXLrtW3YPHLR/D7DR9NbsqFOz5vIfu+eOXDzDI+zkcbv6DnIx3+ISnmALh9nO4ScuYOGxae45tZc8+38lQUQ2A38K7AQOAq9W1eOxZ64EfhdYjxEx3qmqf2q/+2NgN0YM/BLwr1T1LCkYpQoo6w7LdcAVwF4ROQi8ALizdENwyT30qRXyGDtDPGeKej7MT5PLpS6r3UXsJMOoK0YRbGPUDp5+jCjWI8Tgn4gUdVGHSXMVe73Ze67eu6glUuMk6s8dNGOXumc6IPS1wz9HZd3b2/HloFpi6OIZgd8G3K2qlwF32//jaAE/par/GLgB+A0R2Wi/+2Pg+4BnAw3gzVkVjpIBpN5/qaonVXWrqu5U1Z3AF4CbfCqgYdFc16aJSUJWVL/obpJQ3WfELJI2jUsgFtsVstuHKZvGIsOA3ZfywUM4fZu2r0yPDt2di9CUG3n0+iEMpUPdksPkux/68v80W7ljKLIYTbPZKsWNsijhTFp7/Wk+zFhmjb+vH8Os7Uk6hmEFXM6zCvAK4AP2/QeAH4s/oKoPqupD9v1h4EngPPv/XWqBOQHsyKpwZAxAVeeB6P7LbwB3RPdfishNo6o3FAOMYKr3N1QyjBOGrDzuSdJh6RJPBt1L2sQ+wuYSUZ9EmygROmW50qGvjsT+B7iCNpst60Ezn5lptF1vjjQwq8+rxq6h+JjF113hgLwReRzOBwbfueNc2PvN3XPL2IXSBII1g17AVhHZ57xuzlHVNlV93L7/LrAt7WERuQaYBL4V+3wt8Hrgb7IqHKkNIOv+y9jne0bZliD0SeTx6/j6pZjmujatpxupR9/SFnV0p0EOYhG/w7VslBF3kMr4okygBeqJ1Bsuo+ubv4CUFuZM0BvvmucEE6FsBl7mfcndPmQEgyX1IT7+g3cnzHXvlnD3RFYfOvUaE6cXYgnz+utq0OK4e1/CysCRNCOwiHwa+B7PV7/o/qOqKiKJHjoicgHwIeANqhpfnP8D+Kyq/u+sxo5tKoi+XEAJl5GUmZ+8Q72nEnLSQmSpPuIMJiihXZ5U0/H6vNcp9oin73SUJ2PqYNmDTGp+GiYynIKbtPsvU8mJPKksunUGSrrterNrDB74zhmrJu1EvXHSKa1Dnflpa0CdTj+txucyjYkN1FOyfaRNk42cMGVTX1GunuZKyHJUtKp6fdJ3IvKEiFygqo9bAv9kwnPrgU9gPCi/EPvulzEqoX8V0p7Vnwoi6yq/Eoh7GmHI0n+mSfV5IyB9mzZT/zpEquyQE0Ze9YBP4h+VfWQU0dM+NZD5PCBhXAl36/rgChFJayqNIEftduchzrhC5zlNWMhkCiMan2WEO4E32PdvAD4ef8DaU/8C+KCqfiT23ZuBfwK81nMq8GL1MwDCbqGKJMK4ZFj28d4lOhGBCJGGsj12stMdd+stoBpy212EcIZIn4tyd0KBMn1jH5fQ44Qt73hFdQQzzIS7BiKkrff4d0leQIXUbynrNL6X8nhJLWWU/cJCzbi6BryGxLuAHxaRh4Dr7f+IyG4R+QP7zKuBHwTeKCJftq8r7XfvxdgN/t5+7lW3uxhbFZAXljikLfxGgnGz+5kvRQANGrHPI+IfeaDEN+EknWDVSpsmm+zxOg/MXasbg134/N4/Ded9f3td/XBm2Uz2n4ZyEOph7rnNe8tVGacyX5khc512EkoSVCJinzRGLiNr0UxsrztOaXaAULTrTeqdWZjqMYLl5v652FDVo8BLPZ/vw7p0quqHgQ8n/D43PR+LE0AWfEQgiTC0aRqSHZNIJpnLNNKmSd6pag4rPee5xCON8Pj0y7kJm6cvjZh/eYS80pvP/TAEbh/KyiIZMUf3BJPo5WXXzKJ5tOTN2BnrQyTMJMZK4O9LFGccR7CNZJWmVl6JWP0ngByGr1C4PuJFjqZpRkKIpP9G4fIH6vP56FsC6UqGIQwmRC0QEYi4VDtMsFDcQ+cEm4AwxtXTYfeM/WlXWZaFrHkG/0nPf4p0jKjxu5M9CAlKMgn2/M8Fqa2sp9RA+5t+QSC9LclMoUyvqCJYOFfrRjqvNozVCWApc4sXkXpC3D7dDdzdtJEqy6OeCRmDMpOohRFox8soI+7Ahfe0kdG/+QRX3zQmEDHhMtMS+8Z4MGLXr04EFjUoKmTt+samkXUpjAeDFxf1xmBUdw6MM1b/CYBAIlSvAQtBkmG0KJMIg0nGVadFY0A/H7mDRsQ6VPrMOgm0HAnRRZpeNWq3r+w48elQHwg+ysPUannUWOQLlMs6WcSJUKjxMaut0fy6iNt72vVBKTuNSfnWapqNJ0hSb7a6EqwrVPicD/qcFAqosjIjyh1bT3zPpe2FJb0TQMV7q91qwFidABYL+dPk9haXb1Pm8d+ezwigysrVE9L2rCC5LCRJhT5DaBn64jJ18n0RzpaQu7l48tSZN5p2GCNpiPotax7LNNIu58jfccJYnACSkEQM0xZnksvm4E1U/d4VTVpeb6D4syEYhU40Td2UtvEjou0bs0g/nHbS8NYXeYiUiAFJ3TLIJO+baE6iNtfwB2WGBjSljWGTVi4vmna9yTSzXWbvm4O0NRKiBozKihhwmpdS3A7gSuurgtAviLn/exVi1Z8AsqTnLKkn6fte3p98t0aZMgMCqBJ+G8IscvlX5zTMxgmDizwSYhARyhmNGjGxpDFq0xhpNtZe5Hi6N1CS4OHORRZjCZnjOp1+HXoCE8uDtBNklpqm8K1jkcq1pIyjFXpY9QwgBFGaXTf3ed9NXoGZENOkrlCf/sEy+zeVj6hEG2s5Slvxk0UScY0zj1DiXySZWlR2RKiTGFdSW4sziEHi6SsrzwnPF6U7WF4yYS5i8A89aST9pssoY3tu2WIBc19hyGuFYWwYQJkeQNGi76o2HCLUr/pJji/oWEOxi7TNaOIM2pkb1iWcRZmOD20aA+1NVwvE8tAESp+FvKWaLccgX1w9liTd+uY5SUL3nQLyeNEUzg5aEtx1GaL+iRC1u6ixNjMn1grKHbSSMBYMYLkvniTJvRvFGWAEDjlexyW3+KYNZZJlBvIUvUBmWFfV5XhaCoHvjumQuY8zSK+XV4kow061lG7bfVjAhI+EvFYYVj0DiBPPkEWVpBooukmiDRqXDgefqwe30S134PN6Lebj3lNhNWn3p7PIdC/NJtBZaQhCpcO4KitLNVAGkckinlGba/jdWNvdOS3X/hFHfD5HcZtZKCLmW4QJtzP2QIXFxapnAKNGj7gVI0aZPu5Dnl5CDW/x9icR/rhawC0/YiwhnjFu+b4xcG0x5jrEQZ/7eLtDI5l9jCWvi6Pv+TRG745TfGy7jLJIVHmsrLT59jGxvkBCp09p8xxHnNEnqUSLwP39kiWEq2wAqxdtS2A61PuCdoZJ4+wiPYFXWiK1eFRodkbTPMQgCVn3ASxHTDIXpHuO65mHSk1cAvKeBLLmwce0XVVfEkKZX951kOwF1zvp+QLl4ljqVBCrGWPPALKQdsQP9XCBcDWQD3nc9/J4VMQlNxfxvrSs8igvunaMjNw1bj2jQBrxSnb1jauweoQo3P+/EZTrp4hAkW+ukxmk25c2jVzSf7wvReNJlruQsVoxFgxgsivjh0kSPiKUtuHLkFDKlDjbdT+xDrVhZLUliTC4GzxtTHxZQ30EoCzDZJo3VhGkqcvijD4JSWMcL9s3Bm0apblOlpX3Ke8e8Ed9p6UtWcJTQGUEXrkoI/ilCNKIV1b0aYQQFUGSbjwUrmQ4ChdKF6FSbpkGwmEN+VGbZUTrqN+GMSilhxLo0DXgrqm09VXGSazlcR3OwjjfCSAim0Xkb0XkIft3U8qz60XkkIj8tue7O0XkgZA6Vz0DSEPc6BX32e47bmd4uqSV3w44SkdYNq5vCfBJ/1lJ8+KG2sQLyD3Bd2WqBnwBc3kJTp75CSWi6arD8twzizCxaMzi45QWwJbkKeWWZz4f3HNpWLKEcOdYrBPA24C7VfUy4G77fxJ+Bfhs/EMR+ed5WjLWDCCC1wvF+cyXonbQSJuPcLdoBhGIUKm8bcsrSjBCInTzHtuT0KCVkodpkOAXqSONCI0C7qUqRZhWX2K4YDfgOtGNcllIy1XloojkH5KWO9Pra4wlfwevAD5g338A+DHfQyJyNebqx0/FPp8Bfg74r6EVVgwgJ9yFHeR2OKCCiGeNHCQW8c1ZY6FbV4itIG+uoWzvomaQxJ+GuPQ5zEknus3KkL6I9fX+D7WnFHWRzYNWbOzKQsgcR+MQnq6h336RZuNxy3dRhJEte+RzA90qIvuc1805atqmqo/b99/FEPk+iEgNuA24xfP7X7HfBRsUV2eKOweh3icukjZsktTkU3XE0aaZkj5gOD2+v8weeRwGacQ0TPJsZ9oHOtT76mnRpEF7JMFCUUbWuKQ7TII+HzpM9t3zHCqldxOfpZzI6sx5s8qGwld2iwYbOZ5Yp/vevetikg5z1BPnOWnPDNwBvXpwRFV3J30pIp8Gvsfz1S+6/6iqiohPZ/ezwF2qekhE3HKvBC5R1f8gIjtDG7vqGQDQJYVZSCM4DVqcYGMp7YkTB1/5TdoD1/plEYckGGNckp4+TDVQBvJI0qOMFI2Xnebqm1f6T2P0cdTpZDJHoBsIZ7L0hOnBzbWZG7t/86LMU0u6EBE2z779sGiIvIBKgKpen/SdiDwhIheo6uMicgHwpOexHwBeLCI/C8wAkyIyC3wb2C0iBzF0/XwR2auqe9LaM1YqoLSFGEmEwxruhpWYiyC6kMToocMJZ7GUBGGEIcnbJF5nkVQKeZFWR+hFLu5JMhIoMhPzFTT6h3v+NLrzHmr7KcLQkhBf63kFlLx7bgxwJ/AG+/4NwMfjD6jqv1DVi1R1J0YN9EFVfZuq/q6qbrefvwh4MIv4w5gxgCLoZUbsLdK+8PSAxe73cZ/MJBAmijO/1F9Ues6qI8QrykUSscnXl7B6iujps9NwFEvVnOT1koRibc/H6CfpBKlDk9ZlSCoIF+4e6RnHy3VQWDQsXiqIdwE/LCIPAdfb/xGR3SLyB0OX7sHYM4C0RZmHQIQav0JcIOMYxn3Ph8HozUGvppB2RfWEuAi6xCfNAyjL6yiOvLmAsqJbfdJ36MU+w1ypmNe+UCaKrMmidyWkRwMP7sXFSMmxXKCqR1X1pap6maper6rH7Of7VPXNnuffr6pv8Xx+UFWvCKlz1TOAOPH0EYnBNA3le24klVdE9RGaQjmtDxGhy+Nm6nufhSLSrdF599fhq7OovaL45TzZMR++//1pRIa7CCYLRdJsDxdQmB3B3Puux+jTGHK8zCWLBq4igVc2/ETfL70N48Ptbuo04pS00YockeNl5fFuyVLRZLUnxIXVV25I24o8l4Q8UmS8rjDngXwqn6KIXz4fwiSLwten/lu9DIMZ5urSpD23Uu9qWIkYKQMQkRtE5JsickBEBqLaROTnRGS/iHxVRO4Wke8dZXviGDZgJ6wON497+ikg2jQNWt3c/fk8Z0ZjVBsmchaGk9yyoozj70flxVREDTfKsXJPq6EQtGu8jjPFZKEke/wjhAhaWchKzFehXIyMAYjIGuB3gB8BdgGvFZFdscfuB3ar6nOAjwDvGVV7fAh1qfMhKew9VHrO46MfN975Nl+aCqIspEm68frynASSkIdBZ9ldXE+pYcvLgs9YPkqpNkTFFH7b2/CxI+6eiNbBio70re4DKIRrgAOq+rCqzgG3Y0Kdu1DVe1Q1EkW+AOwouxER8YwTJB+BCtHTu77IPsOvP/Pk8CqCKJtp2R4R0SnDJxm6YxRqw3AJndvWSIKue4hDlDQssr0UtcGEeky5dbiBTUnti89zWaeM+EkvD5EOQdTWotJzqNdX3uj4pDqSEI33knsDrUKI6miyHIrIq4AbIuu1iLweeL7Pam2//23gu6o6kMfChlPfDLBt27arb7/99uB2PDV7kmMzNdYwzwTz1FDWcM6+zGcT9n+ABWoowgI1Frp/a5zrPrWGOdZyLhZDFzGaNcwzyVnWcI4JznbrdKV4V51gWrGGs0w6rVpj22Hq3jy70NeHXkvOISz09cu0WjnHGhTpluW2f96WdI4JFEFsTb3eLthv5/vqjNqt9CIQF6wMEY3JOdbYXk902w+wZXaBIzNrumPill/r1qvd9kfjFW9v1IcFpK8PZuwHx6PIPM/39XwtgrJldoGjM7Xu0+ab+W75k5ztWwfuPEfzEJXnzrE7z9FcROXVWOjrQzQvYvsWtd8dD7X/++Z56+w5js/Q7a27jtYy1zc+vnmO6nD7cNYS8GieI/R6O9/Xft88R32Yt7umN8e1vvWrCDtmYWZmJnPfR7juuuvuS4vMDYGct1v5sX1hD/+BDF3fYmJZRAKLyOuA3cBLfN+r6vuA9wHs3r1b9+zZE1z2e/f+FX+xZ4E682zhKJN02MQJNtrXFo4yw3EbXt/qkwznnZD36BfH7d/DbO/WYSQTs1k2Mst2Hu8+vZ3HqdNBISZdG/XTCTYyy0YeZ3tf+T3JdIp/sbfDH++ps8m2d6PTmjpzbOEodTqs50S3jqgfJ9jEUbZ0359gIy0atoRNnGCDcwKY7+bY2cgJtvHEwBjBoGTYoc5RtnRb9QTbbJ11QGnR4HV7z9g+tNnC0W7ZG22bI2l1ilZ3LqLxifrgzsGcrbPDGk6wwY79CTZyqitR++Z5Iyf6xidpnqM+HMcQm9ftPcNH9ygg3bXk9iGaA3ee3fE6wSYOc0F3DqJ5cOd5jnq3Dxs50Z2HaFU0afet1agfJ9jIfHc8JvvqiPowR53/Z+9JPrpHu/O80XnyAg6ziROst+MTn2OBbh3R+PTvA+07/UZrNWSeoz7Mdp/sX6dtmt0+vHvvAnn2f4V0jFIF9BjwDOf/HfazPojI9Zg8GDep6qJbesrOw5PXnztSfRRBVqK5YfqVlsMlq/wQNUCITrxMd9M88xzStrA+lucRlBTNXNacR4woBKOKOnZR5G6MkWEB6AS+VhhGyQDuBS4TkYtFZBJ4DSbUuQsRuQr4PQzx9+W9GCmG2Tw+fbOPaCalwc1jjMzyQCni850F3yYP1Qkn5TAKqSOqJyRFRN5sl1F5aR4vIakgQupwy4TRzJGLrPKLRgJnMRxfVHyejKxForErlIeRMQBVnQfeAnwS+AZwh6p+XUTeISI32cd+DZPQ6M9E5MsicmdCcYUREc/4glwqX+NQJhMZCCPkNRAmEZ44k0ozPkaeM3mIVx4CWqcTxIRHw+AGI5ijNsXhY/J5E5MZ1Uey11kel9+kS1pC4HMBDUXYrW+jI9hVIFj5GKkNQFXvAu6KffZLzvvEzHiLjShDZ1HXwzTPkA71XJ4jSal1G7Q8EZeTNGjhplQeBWFws1z2S7h17/uozLhXUNSH+Hj4vHBc5FWnhLpB+hhW5DkTjWsSTC/83yeNV7x/0TMhAkmUETReZtbtab71lD/ALbl98XkOReiey5qHCsUxFpHAed32Ru2znHWsLq/c9ACuIu6MoQFDPUNoOmNMKzMJSYw3ra406bX/Uvd0QgeDjNgXKQvJt8oN45oZR9bYFZX2887JcttjpeIc8HTga4VhLBiAD/0+7oMSVB6JIyzsfZA4tGkGHauLXGpTFHkSw0V9GgVxy5PmOPS+B7fcOIqemiJEY5DGBOL1FkkFPaqMmpGqz2cjKVv69kXHZ9UxynsqxhljywBCj9xZyLMwk+ocJiJ5sI50/XCRXDehSBoLf9Bd8SysWfCpyeJ15s1KKQlMOC9hSut3fC6Syo7beUKR1AdTl38NFhGEip7Elq1BWKm8gFYqsqTnLG+TpKjUukePPYrUtfE6QoyPo0xI1qsjru9PZ2JpxKdonT7kc8MNI24haqwi5SbBd2lO1l3SeZwLykJkJ3GRFLXrM7pn7b3KA2j0WPUMIA2+hTdq3WRR4jDKI3BeFVaWi2hZ9UTwzYlPzeQjbll2hqxTXhqTzzIQ+97nOSXFUVYfQhFiD0lDGgFPM56PK0Rks4j8rYg8ZP9uSnjuIhH5lIh8wybT3Gk/FxF5p4g8aL/7t1l1jh0DSLoQG9ITdyXluImQ5JPu0/OHXiTiI2g+wldk08T7EHqVZbztacRnGGkzJClZkSygZSQ7S6oza56T4I5T1pjlqcOXlA1Cb7EbnOekccs7z77YmKR1tCyygJ5jsdxA3wbcraqXAXfb/334IPBrqvosTM61KIbqjZjg2++z32XmzBkLBhCFoMcXU/odwen+86HlJJWX5ELoCzCL1CdpG9dNqOYirj5w+5HW7hC9fRoxitqaVEdW0Fwo4vESoUizBySVF/WliJqpzKygebyn0trqfufaSUKYfPyZUd7cNUaqoFcAH7DvPwD8WPwBm1F5QlX/FkBVZ52Emj8DvENVF+x3mcG1q54BpOmeh5GcowXvW/hlqmuKlB/PcJmGIsFmeeH2IamOEJ/zxfYEcdsa6omVl4klnWKGuVoxCaP2Jouv1aIMPenzJfMEUvKkg94qIvuc1805atqmqo/b998FtnmeuRw4ISIfFZH7ReTXbOp9gEuAn7D1/rWIXJZV4bJIBrccEAVr5bn8pMjRN4TITtIZMPaWKWE1afeVX6TspBQXSchDQEfFiNxAquj/EJjxSc9A6QZ+JfVhMe4GiFCn0+1flHDNRfjFM/4xcsuPwxd17wbFucFvRYPIljGOpGUDFZFPA9/j+eoX3X9UVUXElwNmAngxcBXwKPCnGNXPHwJ14Iyq7haRfw78kX02Eav+BJAFn/69aOqBEMIVLzs0z3rZSCIASZ+77S46PkkqFN8cRKqIMtJAhJwuknz0y0ibEKJOdOsZpd476+IcF0VSP4SO16hzI5WKEm0A9rL3KzyvjwNPiMgFAPavT4VzCPiyvWdlHvgY8Fznu4/a938BPCerPWPPACDL+DvoQ+7boCG3dEXIu/jzHN1HFSgUIantIbdSZf2uqEquQSsXoU465RXVqRed52EJfZ65HsZQ66JIwsQISYy+aPmrEHcCb7Dv3wB83PPMvcBGETnP/v9DwH77/mPAdfb9S4AHsypc9QygqN6zzIWYlOAsNAVBHD4vItfbKI/knEUYktIZxL9P0vMXOcUktT3eb991nMOqNtK+T+pXWg6mPFJ0HunZjcL2xwkUW0/xdRkh70k1bR6S3K8XI36lEBRoB76Gw7uAHxaRh4Dr7f+IyG4R+QMAVT0H3ALcLSJfw1xE8vvO719pP/9V4M1ZFY6FDSBUNZOUhC2O0HTHLlzdpw91OrRLPhanbaq0gDKf5OZreyiTNOWF3+LkQ7yutLkqqpbIg3hitigQLmue3Ta2aAzYe9J9581cjtLjxgdf5HFSRLnP/pFkvM2z52Dx+73YUNWjwEs9n+/DIebWA2hAvaOqJ4AfzVPnqj8BlAGfAS3p/tm0Y2+RC07K8AZJCqQaxsaQVW9cAoxOYkmSoS+FhUsYytr8RXTPTdp9J8mssSviLz+qeXaRNgdpkfB54OuHL/dPXiypK+g54HTga4VhbBhAiGpgGBe+UBRVLYVeHJ50hM8qG8KP7UUjqPOMlxucl5S73y039CL4eNnRd74y8zDJtNQMIX0ogqx5LrMPcQyb/TMrAMzFsggGW6UYGwYAxS9VCUXoQnVzoESEIU1nG7djZCUJi78vC0lRtMtWd2uxVIbFUdXr2nuS6ih6pWJWfp54maMmzmMUBLYkWPUMYLFSKefdCCFGtawyyzxaj2IjFy1zMQh20TrKnOc4ihK7PGnMQ1SLecdmsST0Jc0GGh4ItqKw6hkAhC3QuOTjI6gN2l7pO5tQF5eQR7W5kqS3vJssq29RVv8iZYVKt0Wf8dWZhBo6snleDEYPpg9FETLPeZHntFFhNBgLBpCFtBz6/WoVc+yOiGcacYt79AyrJknT5cZVP3lVWEWZTJ4+pRGfYbKyum0PZfR568szPkkXzpjvsr3H8thhQlR+ZahpBhlzeuK2PIwydK0uuR1AA18rDBUD8KAMnXaDNvHkbGnEIYIvn3qo5JZW9rDh9v1qhux++BBikMzKe+/CV1aIG2VI2VFZRU9J8fEyrqLJRMytJ1+yufxMPirf3AOdPl5xYm3SOiT/Jk3FlMXUq5PA4mPVM4CIeLqL3kXeRVfGVZG9s8Pojad53DWzThh52lymvjakD1kS4lIQl5DxcsepqKpsGPhOqmntzuP9k36RTvj9EaO0U4VhgcWKBFtsrHoGkAb/3aTF/PbBFwOwdEmuFtMzJzSdcmgZISkDhsUw8wzDCxIuitwNHAJfGf0poIdPw5DF6OOnBd88F72Lu8LwGAsGEBpkUybxD43qLVsydaW3otknhyE+7oYvcvFI7/N06Tnp6sHs+gbVGlltcdGfAqK4xJc0xnl89vMy+TR34qy++9apOwfDejAtb/VPdQIYa/iu9HMjgUMYTMgCjxOUtLLjDGZY6S3vBm53W5d9a1c8kjatzJDP0urKgzypLGoslDbPSXUURcgcDFN2KJNsOquibFTxAKPBWDGAPNcGhiDt6O6TDrMIRNKpwSU+aeXH60pCniCh+O1TycFg0XPJJ58kO4yLoozM7UO8/Dw3aMXLSPeX7yXf6//c76FThnpjsRjMMMysv5zBMcpT9pJdAtOHBeBU4GtlYdUzgLyBYIsVhNTvrtlPGPIs+jwX2PgQmriraPlFMEw9ZTP5YZCXiIYw4qhc3/syHBTKIvwhyBsHUJ0CyseqZwARQq5RTJNsR4lQqT7ZqyhZuhqGKCRJuGkI7YP7nK/8sgmRewooa57z2AB8J6S80m2oFJ0nq2zUh8WQtJPmOf59vP1LfwqobAAVHCQtyFDiFofvmWGIQwji5Ze9yYq0f1hmW/Ry+H7Cmk08R02QlqL8vOs0i3GECCtJGMa4XiEfxoIBpPsjJy/ItO+iMutdEjKaOtx68iJrs2WVHboR0y5xTxqbJELrv5UtvfxQDF6kEz4+gqbWF8rA4mMaLzOrP8leU8ljFCHqQ96ys76Lz3ORPoTOxWqGiGwWkb8VkYfs300Jz71HRL4uIt8Qkd8SEbGfv1ZEviYiXxWRvxGRrVl1rnoGIAFRtD7CELKZk/Wog8St07dN/GUnEcWQPkR1+N6nITxnTr37N60vaX3IW1f8fRLyMoI0+Ah0EkLnuew+ZDGyLCbjIo0Rp63XpN+Nao7zlF0+zrFIRuC3AXer6mXA3fb/PojItcALMRfCXAE8D3iJiEwAvwlcp6rPAb4KvCWrwrG4ESwEZev62zQywuyL1zdMuQ3auXTEecouE6Oqa7EDjUIZpA9LMc/LYY7LvhlvBeEVwB77/gPAXuCtsWcUmAImMddBrgWesO8FmBaRo8B64EBWhSM9AYjIDSLyTRE5ICI+blYXkT+1339RRHaOsj3DYpS6ycVc9CH9GGc9bJ6+L2ditRLneXmOZy4j8FYR2ee8bs5R0TZVfdy+/y6wLf6Aqv49cA/wuH19UlW/oapngZ8BvgYcBnYBf5hV4cgYgIisAX4H+BHbmNeKyK7YY28CjqvqpcB/A949qvYsZ5QlFebBKDb+Ymze5UawIE/U9+qY51FheRL/3Diiqrud1/vcL0Xk0yLygOf1Cvc5VfXmFxWRS4FnATuAC4EfEpEXi8haDAO4CtiOUQH9QlZjR6kCugY4oKoPA4jI7Zgjzn7nmVcAb7fvPwL8toiI7fyKR5YaKHpmuWElEY0shMzBYrVjqTCM2m+xENK+d/HL7GXv6BszgAXg6VJKUtXrk74TkSdE5AJVfVxELgCe9Dz2z4AvqOqs/c1fAz+AvY5GVb9lP78Djw0hjlEygAuB7zj/HwKen/SMqs6LyElgC3DEfcgeo24G2LZtG3v37g1uxIbZddyw9yV5276sMDs7W/VhibHS2w8rvw972cvs7Gyu/b/CcCfwBuBd9u/HPc88Cvy0iPwqRuf/EuA3gMeAXSJynqo+Bfww8I2sCleEEdgeo94HsHv3bt2zZ0/wb/fu3Uue55cjqj4sPVZ6+6HqQ3FEXkAjx7uAO0TkTcC3gVcDiMhu4P9V1TdjNCU/hNH1K/A3qvqX9rn/AnxWRM7a378xq8JRMoDHgGc4/++wn/meOWTdmDYAR0fYpgoVKlRYllDVo8BLPZ/vA95s358D/lXC798LvDdPnaP0AroXuExELhaRSeA1mCOOi+jIA/Aq4O9Wi/6/QoUKqwWrNxXEyE4AVqf/FuCTwBrgj1T16yLyDmCfqt6JcVP6kIgcAI5hmESFChUqVFgEjNQGoKp3AXfFPvsl5/0Z4MdH2YYKFSpUGA6LZgNYdKz6VBAVKlSoUMGPigFUqFChwphiRbiBVqhQocLSITICrz5UJ4AKFSpUGFPISvO6FJGnMEEOodhKLLJ4BaLqw9JjpbcfxrMP36uq5w1ToYj8ja03BEdU9YZh6ltMrDgGkBcisk9Vdy91O4ZB1Yelx0pvP1R9qDCISgVUoUKFCmOKigFUqFChwphiHBjA+7IfWfao+rD0WOnth6oPFWJY9TaAChUqVKjgxzicACpUqFChggcVA6hQoUKFMcWqYQCr4QL6gD78nIjsF5GvisjdIvK9S9HOJGS133nulSKi9qKLZYWQPojIq+08fF1E/tditzELAevoIhG5R0Tut2vpxqVoZxJE5I9E5EkReSDhexGR37L9+6qIPHex27hqoKor/oVJN/0t4B8Bk8BXgF2xZ34WeK99/xrgT5e63QX6cB3QtO9/Zjn1IaT99rl1wGeBLwC7l7rdBebgMuB+YJP9//ylbneBPrwP+Bn7fhdwcKnbHWvfDwLPBR5I+P5G4K8xVyK+APjiUrd5pb5WywmgewG9qs4B0QX0Ll4BfMC+/wjwUhGRRWxjFjL7oKr3qGrL/vsFzC1rywUhcwDwK8C7sZdYLzOE9OGngd9R1eMAquq7uHspEdIHBdbb9xuAw4vYvkyo6mcx94Mk4RXAB9XgC8BGe4l6hZxYLQzAdwH9hUnPqOo8EF1Av1wQ0gcXb8JIQcsFme23R/VnqOonFrNhORAyB5cDl4vI50TkCyKy3ML+Q/rwduB1InIIc1/Hv1mcppWGvHulQgKqbKArECLyOmA38JKlbksoRKQG/DoBF1Uvc0xg1EB7MCewz4rIs1X1xFI2KideC7xfVW8TkR/A3Mp3haouLHXDKiwuVssJIM8F9CzTC+hD+oCIXA/8InCTqnYWqW0hyGr/OuAKYK+IHMTobu9cZobgkDk4BNypqmdV9RHgQQxDWC4I6cObgDsAVPXvgSnCk50tBwTtlQrZWC0MYDVcQJ/ZBxG5Cvg9DPFfbrrn1Par6klV3aqqO1V1J8aGcZOq7lua5noRso4+hpH+EZGtGJXQw4vYxiyE9OFR4KUAIvIsDAN4alFbORzuBH7KegO9ADipqo8vdaNWIlaFCkhXwQX0gX34NWAG+DNrv35UVW9askY7CGz/skZgHz4JvExE9mMui/2PqrpsTpKBffh54PdF5D9gDMJvXE7CkIj8CYbJbrV2il8G1gKo6nsxdosbgQNAC/iXS9PSlY8qFUSFChUqjClWiwqoQoUKFSrkRMUAKlSoUGFMUTGAChUqVBhTVAygQoUKFcYUFQOoUKFChTFFxQAqVKhQYUxRMYAKFSpUGFNUDKDCioWIPM/mg58SkWmbn/+KpW5XhQorBVUgWIUVDRH5r5hUBg3gkKr+6hI3qUKFFYOKAVRY0bD5bu7F3C9wraqeW+ImVaiwYlCpgCqsdGzB5EdahzkJVKhQIRDVCaDCioaI3Im59epi4AJVfcsSN6lChRWDVZENtMJ4QkR+Cjirqv9LRNYAnxeRH1LVv1vqtlWosBJQnQAqVKhQYUxR2QAqVKhQYUxRMYAKFSpUGFNUDKBChQoVxhQVA6hQoUKFMUXFACpUqFBhTFExgAoVKlQYU1QMoEKFChXGFP8/Ml1SBdJVWAUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_sampler = tp.samplers.PlotSampler(plot_domain=square, n_points=2000)\n", + "fig = tp.utils.plot(model, lambda u,x,y: u-torch.cos(20*math.pi*x)*y, plot_sampler, plot_type='contour_surface')\n", + "plt.title('error')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by resetting our network (defining a new one). With fewer parameters, because we implement the high frequencies via hard constrains and therefore the network now has to learn a simpler function. \n", + "\n", + "For the hard constraints, we create the following python-function, where we choose the ansatz to just multiply the network output with the boundary function:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "model = tp.models.FCN(input_space=XY, output_space=U, hidden=(10, 10))\n", + "\n", + "def constrain_fn(u, x):\n", + " return u*bc_fn(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The hard constraints now have to be always be applied inside our residual functions of the different conditions. One important point is, that our constraints do not automatically fulfill any boundary condition. So we still have all previous conditions.\n", + "\n", + "Choosing for example the constraint: $u*(1-y) + \\sin(20\\pi x)$, would naturally fulfill the boundary condition at $y=1$. What we choose is somewhat arbitrary, important for this problem is that the oscillation appears in the constrain function." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def pde_residual(u, x, y):\n", + " u = constrain_fn(u, x) # plug in output of model to apply constraint\n", + " return tp.utils.grad(u, y) - u/(y + tol)\n", + "\n", + "pde_condition = tp.conditions.PINNCondition(module=model,\n", + " sampler=inner_sampler,\n", + " residual_fn=pde_residual,\n", + " name='pde_condition')\n", + "\n", + "def dirichlet_residual(u, x, y):\n", + " u = constrain_fn(u, x) # again apply constraint\n", + " return u - y * bc_fn(x)\n", + "\n", + "dirichlet_condition = tp.conditions.PINNCondition(module=model,\n", + " sampler=y_sampler,\n", + " residual_fn=dirichlet_residual,\n", + " name='diri_condition')\n", + "\n", + "def neumann_residual(u, x):\n", + " u = constrain_fn(u, x) # again apply constraint\n", + " return tp.utils.grad(u, x) # = 0\n", + "\n", + "neumann_condition = tp.conditions.PINNCondition(module=model,\n", + " sampler=x_sampler,\n", + " residual_fn=neumann_residual,\n", + " name='neu_condition', weight=1/60)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We choose the same training parameters. Where most likely are smaller learning rate would be better, since the loss starts to oscillate. But the results will be good enough, to show the advantage of the hard constraint for this type of problem." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 151 \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "151 Trainable params\n", + "0 Non-trainable params\n", + "151 Total params\n", + "0.001 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3911fffc31044d148a31af54c8e6c3cb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "341b8ee669294274a60dc842249d4181", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "055f73d258ee46dab90fe441a5f10de3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.001)\n", + "\n", + "solver = tp.solver.Solver([pde_condition, dirichlet_condition, neumann_condition], optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " max_steps=5000,\n", + " logger=False,\n", + " benchmark=True,\n", + " checkpoint_callback=False)\n", + " \n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'learned solution')" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_sampler = tp.samplers.PlotSampler(plot_domain=square, n_points=2000)\n", + "fig = tp.utils.plot(model, constrain_fn, plot_sampler, plot_type='contour_surface')\n", + "plt.title('learned solution')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'error')" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_sampler = tp.samplers.PlotSampler(plot_domain=square, n_points=2000)\n", + "fig = tp.utils.plot(model, lambda u,x,y: constrain_fn(u,x)-torch.cos(20*math.pi*x)*y, plot_sampler, plot_type='contour_surface')\n", + "plt.title('error')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.9.15 ('bosch')", + "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.15" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "fb770cb910411e790a99fd848f827dc995ac53be5098d939fbaa56bcec3c9277" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 69d31794785af42625774588d7a55af5f264183a Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Wed, 18 Jan 2023 15:30:09 +0100 Subject: [PATCH 02/30] Save traininer state Signed-off-by: Tom Freudenberg --- src/torchphysics/utils/__init__.py | 2 +- src/torchphysics/utils/callbacks.py | 43 ++++++++++++++++++++++++++++- 2 files changed, 43 insertions(+), 2 deletions(-) diff --git a/src/torchphysics/utils/__init__.py b/src/torchphysics/utils/__init__.py index 46bbd69d..8e54974e 100644 --- a/src/torchphysics/utils/__init__.py +++ b/src/torchphysics/utils/__init__.py @@ -24,4 +24,4 @@ from .plotting import plot, animate, scatter from .evaluation import compute_min_and_max -from .callbacks import (WeightSaveCallback, PlotterCallback) \ No newline at end of file +from .callbacks import (WeightSaveCallback, PlotterCallback, TrainerStateCheckpoint) \ No newline at end of file diff --git a/src/torchphysics/utils/callbacks.py b/src/torchphysics/utils/callbacks.py index dbfd5498..bee78fe8 100644 --- a/src/torchphysics/utils/callbacks.py +++ b/src/torchphysics/utils/callbacks.py @@ -107,4 +107,45 @@ def on_train_batch_end(self, trainer, pl_module, outputs, batch, global_step=batch_idx) def on_train_end(self, trainer, pl_module): - return \ No newline at end of file + return + + +class TrainerStateCheckpoint(Callback): + """ + A callback to saves the current state of the trainer (a PyTorch Lightning checkpoint), + if the training has to be resumed at a later point in time. + + Parameters + ---------- + path : str + The relative path of the saved weights. + name : str + A name that will become part of the file name of the saved weights. + check_interval : int, optional + Checkpoints will be saved every check_interval steps. Default is 200. + weights_only : bool, optional + If only the model parameters should be saved. Default is false. + + Note + ---- + To continue from the checkpoint, use `resume_from_checkpoint ="path_to_ckpt_file"` as an + argument in the initialization of the trainer. + + The PyTorch Lightning checkpoint would save the current epoch and restart from it. + In TorchPhysics we dont use multiple epochs, instead we train with multiple iterations + inside "one giant epoch". If the training is restarted, the trainer will always start + from iteration 0 (essentially the last completed epoch). But all other states + (model, optimizer, ...) will be correctly restored. + """ + def __init__(self, path, name, check_interval=200, weights_only = False): + super().__init__() + self.path = path + self.name = name + self.check_interval = check_interval + self.weights_only = weights_only + + + def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx): + if batch_idx % self.check_interval == 0: + trainer.save_checkpoint(self.path + '/' + self.name + ".ckpt", + weights_only=self.weights_only) From 66ed61a573752411c1103be38ce6247255ceea4e Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Wed, 18 Jan 2023 15:30:30 +0100 Subject: [PATCH 03/30] enable resampling in static sampler Signed-off-by: Tom Freudenberg --- .../problem/samplers/sampler_base.py | 33 +++++++++++++++---- 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/src/torchphysics/problem/samplers/sampler_base.py b/src/torchphysics/problem/samplers/sampler_base.py index 938a6ca3..b570a0b2 100644 --- a/src/torchphysics/problem/samplers/sampler_base.py +++ b/src/torchphysics/problem/samplers/sampler_base.py @@ -3,6 +3,7 @@ import abc import torch import warnings +import math from ...utils.user_fun import UserFunction from ..spaces.points import Points @@ -92,15 +93,22 @@ def __len__(self): Set the length by using .set_length, if this property is needed""") - def make_static(self): + def make_static(self, resample_interval =math.inf): """Transforms a sampler to an ``StaticSampler``. A StaticSampler only creates points the first time .sample_points() is called. Afterwards the points are saved and will always be returned if .sample_points() is called again. Useful if the same points should be used while training/validation or if it is not practicall to create new points in each iteration (e.g. grid points). + + Parameters + ---------- + resample_interval : int, optional + Parameter to specify if new sampling of points should be created after a fixed number + of iterations. E.g. resample_interval =5, will use the same points for five iterations + and then sample a new batch that will be used for the next five iterations. """ - return StaticSampler(self) + return StaticSampler(self, resample_interval) @property def is_static(self): @@ -314,19 +322,26 @@ def sample_points(self, params=Points.empty(), device='cpu'): class StaticSampler(PointSampler): """Constructs a sampler that saves the first points created and - afterwards always returns these points again. Has the advantage - that the points only have to be computed once. + afterwards only returns these points again. Has the advantage + that the points only have to be computed once. Can also be customized to created new + points after a fixed number of iterations. Parameters ---------- sampler : Pointsampler The basic sampler that will create the points. + resample_interval : int, optional + Parameter to specify if new sampling of points should be created after a fixed number + of iterations. E.g. resample_interval =5, will use the same points for five iterations + and then sample a new batch that will be used for the next five iterations. """ - def __init__(self, sampler): + def __init__(self, sampler, resample_interval=math.inf): self.length = None self.sampler = sampler self.created_points = None + self.resample_interval = resample_interval + self.counter = 0 def __len__(self): if self.length: @@ -339,9 +354,12 @@ def __next__(self): return self.sample_points() def sample_points(self, params=Points.empty(), device='cpu', **kwargs): - if self.created_points: + self.counter += 1 + if self.created_points and self.counter < self.resample_interval: self._change_device(device=device) return self.created_points + # reset counter if over self.resample_interval and create new points + self.counter = 0 points = self.sampler.sample_points(params, device=device, **kwargs) self.created_points = points return points @@ -349,7 +367,8 @@ def sample_points(self, params=Points.empty(), device='cpu', **kwargs): def _change_device(self, device): self.created_points = self.created_points.to(device) - def make_static(self): + def make_static(self, resample_interval=math.inf): + self.resample_interval = resample_interval return self From 1bfceb4cdefa413b3f842d983f2f9b621979a811 Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Wed, 18 Jan 2023 15:31:09 +0100 Subject: [PATCH 04/30] add examples Signed-off-by: Tom Freudenberg --- docs/tutorial/solve_pde.rst | 79 ++++- examples/deepritz/corner_pde.ipynb | 308 ++++++++++++++++ examples/tutorial/solve_pde.ipynb | 172 ++++++--- examples/tutorial/solve_pde_drm.ipynb | 485 ++++++++++++++++++++++++++ 4 files changed, 983 insertions(+), 61 deletions(-) create mode 100644 examples/deepritz/corner_pde.ipynb create mode 100644 examples/tutorial/solve_pde_drm.ipynb diff --git a/docs/tutorial/solve_pde.rst b/docs/tutorial/solve_pde.rst index 85b809b7..99e3b17c 100644 --- a/docs/tutorial/solve_pde.rst +++ b/docs/tutorial/solve_pde.rst @@ -1,13 +1,12 @@ ==================== Solving a simple PDE ==================== -The following problem also exists as an notebook_. Here we assume that you know all the -basic concepts, that were part of the previous tutorials and will only give short explanations -to every step. +The following problem also exists as an notebook_. Here we give a beginner-friendly introduction +to TorchPhysics, going over all the basic concepts and steps. .. _notebook: https://github.com/boschresearch/torchphysics/blob/main/examples/tutorial/solve_pde.ipynb -Our aim is to solve the following PDE: +We introduce the library with the aim to solve the following PDE: .. math:: @@ -18,7 +17,12 @@ Our aim is to solve the following PDE: For comparison, the analytic solution is :math:`u(x_1, x_2) = \sin(\frac{\pi}{2} x_1)\cos(2\pi x_2)`. -We start by defining the spaces for the input and output values. +Generally, the first step is to define all appearing variables and giving them a *name*. +In TorchPhysics all input variables are considered as variables that have to be named, +but also the solution functions. +From a mathematical point of view we essentially define to what ``space`` these variables +*belong* (for example :math:`x \in \mathbb{R}^2`). From a more applied point, we just set the name +and dimension of our input and output values: .. code-block:: python @@ -26,22 +30,51 @@ We start by defining the spaces for the input and output values. X = tp.spaces.R2('x') # input is 2D U = tp.spaces.R1('u') # output is 1D -Next up is the domain: +Next up is the domain, in our case a simple square. There are a lot of different domains +provided in TorchPhysics (even logical operations and time dependencies are possible), +these will be introduced further later in the tutorial and can be found under the section +``domains``. + +Usually a domain gets as an input the space it belongs to (here our 'x') and some different +parameters that depend on the constructed object. For a parallelogram, for example the origin +and two corners. .. code-block:: python square = tp.domains.Parallelogram(X, [0, 0], [1, 0], [0, 1]) -Now we define our model, that we want to train. Since we have a simple domain, we do not use any -normalization. +Now we define our neural network, that we want to train. There are different architectures +pre implemented, but since we build upon PyTorch one can easily define custom networks and use them. + +For this example we use a simple fully connected network. +In TorchPhysics all classes that handle the networks are collected under the ``models`` section. .. code-block:: python model = tp.models.FCN(input_space=X, output_space=U, hidden=(50,50,50,50,50)) -The next step is the definition of the conditions. For this PDE we have two different ones, the -differential equation itself and the boundary condition. We start with the boundary condition: +The next step is the definition of the training conditions. +Here we transform our PDE into some residuals that we minimize in the training. +From an implementation point, we stay close to the original (mathematical) PDE and to the +standard PINN approach. + +Here we have two different conditions that the network should fulfill, the differential +equation itself and the boundary condition. Here, we start with the boundary condition: + + - For this, one has to first define a Python-function, that describes our trainings condition. + As an input, one can pick all variables and networks that appear in the problem and were defined + previously, via the ``spaces``. The output should describe how well the considered condition + is fulfilled. + In our example, we just compute the expected boundary values and return the difference to + the current network output. Here, ``u`` will already be the network evaluated at the points + ``x`` (a batch of coordinates). Internally, this will then be transformed automatically to + an MSE-loss (which can also be customized, if needed). + - We also need to tell on which points this condition should be fulfilled. + For this TorchPhysics provides + the ``samplers`` section. Where different sampling strategies are implemented. + For the boundary condition we only need points at the boundary, in TorchPhysics all # + domains have the property ``.boundary`` that returns the boundary as a new domain-object. .. code-block:: python @@ -56,11 +89,28 @@ differential equation itself and the boundary condition. We start with the bound # here we use grid points any other sampler could also be used bound_sampler = tp.samplers.GridSampler(square.boundary, n_points=5000) bound_sampler = bound_sampler.make_static() # grid always the same, therfore static for one single computation - # wrap everything together in the condition + +Once all this is defined, we have to combine the residual and sampler in a ``condition``. +These condition handle internally the training process. +Under the hood, they have the following simplified behavior (while training): + + 1) Sample points with the given sampler + 2) Evaluate model at these points + 3) Plug points and model output into the given residual + 4) Compute corresponding loss term + 5) Pass loss to the optimizer + +In TorchPhysics many different condition types are pre implemented +(for including data, integral conditions, etc.). +Here we use the PINN approach, which corresponds to a ``PINNCondition``: + +.. code-block:: python bound_cond = tp.conditions.PINNCondition(module=model, sampler=bound_sampler, residual_fn=bound_residual, weight=10) -It follows the differential condition, here we use the pre implemented operators: +The same holds for the differential equation term. Here also different operators are implemented, +that help to compute the derivatives of the neural network. +They can be found under the ``utils`` section. .. code-block:: python @@ -156,4 +206,7 @@ We can plot the error, since we know the exact solution: Now you know how to solve a PDE in TorchPhysics, additional examples can be found under the `example-folder`_. -.. _`example-folder`: https://github.com/boschresearch/torchphysics/tree/main/examples \ No newline at end of file +And more in-depth information can be found on the `tutorial page`_. + +.. _`example-folder`: https://github.com/boschresearch/torchphysics/tree/main/examples +.. _`tutorial page`: https://torchphysics.readthedocs.io/en/latest/tutorial/tutorial_start.html \ No newline at end of file diff --git a/examples/deepritz/corner_pde.ipynb b/examples/deepritz/corner_pde.ipynb new file mode 100644 index 00000000..0bbadad5 --- /dev/null +++ b/examples/deepritz/corner_pde.ipynb @@ -0,0 +1,308 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "PDE with corner singularity\n", + "===========================\n", + "\n", + "\\begin{align*}\n", + " -\\Delta u &= 1 \\text{ in } \\Omega \\\\\n", + " u &= 0 \\text{ on } \\partial \\Omega\n", + "\\end{align*}\n", + "\n", + "With $\\Omega=([-1, 1] \\times [-1, 1]) \\setminus ([0, 1] \\times \\{0\\})$" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n", + "import torchphysics as tp \n", + "import torch\n", + "X = tp.spaces.R1('x') \n", + "Y = tp.spaces.R1('y')\n", + "U = tp.spaces.R1('u') # output is 1D and named u" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "square = tp.domains.Parallelogram(X*Y, [-1, -1], [1, -1], [-1, 1])\n", + "line = tp.domains.Interval(X, 0, 1) * tp.domains.Point(Y, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "model = tp.models.DeepRitzNet(input_space=X*Y, output_space=U, width=20, depth=4)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def bound_residual(u, x):\n", + " return u**2\n", + "\n", + "bound_sampler = tp.samplers.RandomUniformSampler(square.boundary, n_points=40000)\n", + "bound_sampler += tp.samplers.RandomUniformSampler(line, n_points=10000)\n", + "\n", + "bound_cond = tp.conditions.DeepRitzCondition(module=model, sampler=bound_sampler, \n", + " integrand_fn=bound_residual, weight=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def energy_residual(u, x, y):\n", + " grad_term = torch.sum(tp.utils.grad(u, x, y)**2, dim=1, keepdim=True)\n", + " return 0.5*grad_term - u\n", + "\n", + "pde_sampler = tp.samplers.RandomUniformSampler(square, n_points=100000) \n", + "pde_cond = tp.conditions.DeepRitzCondition(module=model, sampler=pde_sampler, \n", + " integrand_fn=energy_residual, weight=1.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.001)\n", + "solver = tp.solver.Solver(train_conditions=[bound_cond, pde_cond], optimizer_setting=optim)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [1]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 3.4 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "3.4 K Trainable params\n", + "0 Non-trainable params\n", + "3.4 K Total params\n", + "0.014 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2912ab89aad0422bb317d376b93ea875", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "855fe299066f4235ac123a35f09a87c2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9eec5369959441baa2398c5cec7a8231", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pytorch_lightning as pl\n", + "\n", + "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", + " max_steps=5000, # number of training steps\n", + " logger=False,\n", + " benchmark=True,\n", + " checkpoint_callback=False)\n", + " \n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [1]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 3.4 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "3.4 K Trainable params\n", + "0 Non-trainable params\n", + "3.4 K Total params\n", + "0.014 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6afa21fb345240e58e0ea6bfded033ba", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8b5b49e29294461195c2067b20157687", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d529b850025c43c7ba6b9c18f72d504b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.LBFGS, lr=0.05, \n", + " optimizer_args={'max_iter': 2, 'history_size': 100})\n", + "\n", + "pde_cond.sampler = pde_cond.sampler.make_static() \n", + "bound_cond.sampler = bound_cond.sampler.make_static() \n", + "solver = tp.solver.Solver(train_conditions=[bound_cond, pde_cond], optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " max_steps=3000, # number of training steps\n", + " logger=False,\n", + " benchmark=True,\n", + " checkpoint_callback=False)\n", + " \n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_sampler = tp.samplers.PlotSampler(plot_domain=square, n_points=640, device='cuda')\n", + "fig = tp.utils.plot(model, lambda u : u, plot_sampler, plot_type='contour_surface')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "fb770cb910411e790a99fd848f827dc995ac53be5098d939fbaa56bcec3c9277" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/tutorial/solve_pde.ipynb b/examples/tutorial/solve_pde.ipynb index 50442b10..c8b576fd 100644 --- a/examples/tutorial/solve_pde.ipynb +++ b/examples/tutorial/solve_pde.ipynb @@ -4,14 +4,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Solving a simple PDE\n", - "====================\n", - "Here we assume that you know all the\n", - "basic concepts, that were part of the previous tutorials and will only give short explanations\n", - "to every step.\n", - "\n", - "\n", - "Our aim is to solve the following PDE:\n", + "Solving a simple PDE with the PINN-approach\n", + "===========================================\n", + "Here we give a beginner-friendly introduction to TorchPhysics, going over all the basic concepts and steps. For a more in-depth explanation, we recommend the [tutorial page](https://torchphysics.readthedocs.io/en/latest/tutorial/tutorial_start.html).\n", + "We introduce the library with the aim to solve the following PDE:\n", "\n", "\\begin{align*}\n", "-\\Delta u &= 4.25\\pi^2 u \\text{ in } \\Omega = [0, 1] \\times [0, 1] \\\\\n", @@ -20,7 +16,8 @@ "\n", "For comparison, the analytic solution is $u(x_1, x_2) = \\sin(\\tfrac{\\pi}{2} x_1)\\cos(2\\pi x_2)$.\n", "\n", - "We start by defining the spaces for the input and output values." + "Generally, the first step is to define all appearing variables and giving them a *name*. In TorchPhysics all input variables are considered as variables that have to be named, but also the solution functions. \n", + "From a mathematical point of view we essentially define to what ``space`` these variables *belong* (for example $x \\in \\mathbb{R}^2$). From a more applied point, we just set the name and dimension of our input and output values:" ] }, { @@ -30,15 +27,17 @@ "outputs": [], "source": [ "import torchphysics as tp \n", - "X = tp.spaces.R2('x') # input is 2D\n", - "U = tp.spaces.R1('u') # output is 1D" + "X = tp.spaces.R2('x') # input is 2D and named x\n", + "U = tp.spaces.R1('u') # output is 1D and named u" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Next up is the domain:" + "Next up is the domain, in our case a simple square. There are a lot of different domains provided in TorchPhysics (even logical operations and time dependencies are possible), these will be introduced further later in the tutorial and can be found under the section ``domains``. \n", + "\n", + "Usually a domain gets as an input the space it belongs to (here our 'x') and some different parameters that depend on the constructed object. For a parallelogram, for example the origin and two corners." ] }, { @@ -54,8 +53,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now we define our model, that we want to train. Since we have a simple domain, we do not use any \n", - "normalization." + "Now we define our neural network, that we want to train. There are different architectures pre implemented, but since we build upon PyTorch one can easily define custom networks and use them.\n", + "\n", + "For this example we use a simple fully connected network. In TorchPhysics all classes that handle the networks are collected under the ``models`` section." ] }, { @@ -71,8 +71,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The next step is the definition of the conditions. For this PDE we have two different ones, the differential\n", - "equation itself and the boundary condition. We start with the boundary condition:" + "The next step is the definition of the training conditions. Here we transform our PDE into some residuals that we minimize in the training. From an implementation point, we stay close to the original (mathematical) PDE and to the standard PINN approach.\n", + "\n", + "Here we have two different conditions that the network should fulfill, the differential\n", + "equation itself and the boundary condition. Here, we start with the boundary condition:\n", + "\n", + " - For this, one has to first define a Python-function, that describes our trainings condition. \n", + " As an input, one can pick all variables and networks that appear in the problem and were defined \n", + " previously, via the ``spaces``. The output should describe how well the considered condition is fulfilled. \n", + " In our example, we just compute the expected boundary values and return the difference to the current network output. Here, ``u`` will already be the network evaluated at the points ``x`` (a batch of coordinates). Internally, this will then be transformed automatically to an MSE-loss (which can also be customized, if needed).\n", + " - We also need to tell on which points this condition should be fulfilled. For this TorchPhysics provides\n", + " the ``samplers`` section. Where different sampling strategies are implemented. \n", + " For the boundary condition we only need points at the boundary, in TorchPhysics all domains have the property ``.boundary`` that returns the boundary as a new domain-object. " ] }, { @@ -88,11 +98,33 @@ " bound_values = torch.sin(np.pi/2*x[:, :1]) * torch.cos(2*np.pi*x[:, 1:])\n", " return u - bound_values\n", "\n", - "# the point sampler, for the trainig points:\n", - "# here we use grid points any other sampler could also be used\n", + "# the point sampler:\n", + "# here we use 5000 grid points any other sampler could also be used\n", "bound_sampler = tp.samplers.GridSampler(square.boundary, n_points=5000)\n", - "bound_sampler = bound_sampler.make_static() # grid always the same, therfore static for one single computation\n", - "# wrap everything together in the condition\n", + "bound_sampler = bound_sampler.make_static() # grid always the same, therfore static for one single computation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once all this is defined, we have to combine the residual and sampler in a ``condition``. These condition handle internally the training process. Under the hood, they have the following simplified behavior (while training):\n", + "\n", + " 1) Sample points with the given sampler\n", + " 2) Evaluate model at these points\n", + " 3) Plug points and model output into the given residual \n", + " 4) Compute corresponding loss term\n", + " 5) Pass loss to the optimizer\n", + "\n", + "In TorchPhysics many different condition types are pre implemented (for including data, integral conditions, etc.). Here we use the PINN approach, which corresponds to a ``PINNCondition``:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ "bound_cond = tp.conditions.PINNCondition(module=model, sampler=bound_sampler, \n", " residual_fn=bound_residual, weight=10)" ] @@ -101,12 +133,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "It follows the differential condition, here we use the pre implemented operators:" + "The same holds for the differential equation term. Here also different operators are implemented, that help to compute the derivatives of the neural network. They can be found under the ``utils`` section. " ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -115,8 +147,9 @@ " return tp.utils.laplacian(u, x) + 4.25*np.pi**2*u\n", "\n", "# the point sampler, for the trainig points:\n", - "pde_sampler = tp.samplers.GridSampler(square, n_points=15000) # again point grid \n", - "pde_sampler = pde_sampler.make_static()\n", + "pde_sampler = tp.samplers.RandomUniformSampler(square, n_points=15000) \n", + "# random points will be resampled in each iteration!\n", + "\n", "# wrap everything together in the condition\n", "pde_cond = tp.conditions.PINNCondition(module=model, sampler=pde_sampler, \n", " residual_fn=pde_residual)" @@ -129,7 +162,7 @@ "The transformation of our PDE into a TorchPhysics problem is finished. So we can start the\n", "training.\n", "\n", - "The last step before the training is the creation of a *Solver*. This is an object that inherits from\n", + "The last step before the training is the creation of a ``Solver``. This is an object that inherits from\n", "the Pytorch Lightning *LightningModule*. It handles the training and validation loops and takes care of the\n", "data loading for GPUs or CPUs. It gets the following inputs:\n", "\n", @@ -141,7 +174,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -161,7 +194,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -170,7 +203,7 @@ "text": [ "GPU available: True, used: True\n", "TPU available: False, using: 0 TPU cores\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", "\n", " | Name | Type | Params\n", "------------------------------------------------\n", @@ -186,7 +219,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1159683cf56546a19179bd4171dc139a", + "model_id": "74bac3a920fc44e9bb6867d0d0cf647a", "version_major": 2, "version_minor": 0 }, @@ -201,16 +234,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " warnings.warn(*args, **kwargs)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " warnings.warn(*args, **kwargs)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a07a216e67f34d9ea840a6f39eb39709", + "model_id": "5a2af6cca27e43749e5f5c3796c61e2a", "version_major": 2, "version_minor": 0 }, @@ -224,7 +257,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0dcc48e9233946719bfdaaadd243d26c", + "model_id": "1161ebb9716844a6a1219082237f9058", "version_major": 2, "version_minor": 0 }, @@ -238,8 +271,10 @@ ], "source": [ "import pytorch_lightning as pl\n", - "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\" # select GPUs to use\n", + "## maybe selcet the GPU to use:\n", + "#import os\n", + "#os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n", + "\n", "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", " max_steps=4000, # number of training steps\n", " logger=False,\n", @@ -258,7 +293,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -267,7 +302,7 @@ "text": [ "GPU available: True, used: True\n", "TPU available: False, using: 0 TPU cores\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", "\n", " | Name | Type | Params\n", "------------------------------------------------\n", @@ -283,7 +318,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cb85c04e33204eee87cf26140e39dabd", + "model_id": "1d1e3c8b0cb749eaaeb7c7ac211135e8", "version_major": 2, "version_minor": 0 }, @@ -297,7 +332,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "bbf5a939e2514697bbd03aa04a9d8cdd", + "model_id": "eb40a61a818e462991f29ab9260e2132", "version_major": 2, "version_minor": 0 }, @@ -311,7 +346,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2c32c8927745481d8c7270e192bf3eaf", + "model_id": "ff6dad5724984b8faa8050ba63588a59", "version_major": 2, "version_minor": 0 }, @@ -327,6 +362,7 @@ "optim = tp.OptimizerSetting(optimizer_class=torch.optim.LBFGS, lr=0.05, \n", " optimizer_args={'max_iter': 2, 'history_size': 100})\n", "\n", + "pde_cond.sampler = pde_cond.sampler.make_static() # LBFGS can not work with varing points!\n", "solver = tp.solver.Solver(train_conditions=[bound_cond, pde_cond], optimizer_setting=optim)\n", "\n", "trainer = pl.Trainer(gpus=1,\n", @@ -347,9 +383,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/torch/functional.py:478: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:2895.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n", + "/home/tomfre/Desktop/torchphysics/src/torchphysics/problem/domains/domain2D/parallelogram.py:134: UserWarning: The use of `x.T` on tensors of dimension other than 2 to reverse their shape is deprecated and it will throw an error in a future release. Consider `x.mT` to transpose batches of matricesor `x.permute(*torch.arange(x.ndim - 1, -1, -1))` to reverse the dimensions of a tensor. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:2985.)\n", + " bary_coords = torch.stack(torch.meshgrid((x, y))).T.reshape(-1, 2)\n", + "/home/tomfre/Desktop/torchphysics/src/torchphysics/utils/plotting/plot_functions.py:416: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:204.)\n", + " embed_point = Points(torch.tensor([center]), domain.space)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plot_sampler = tp.samplers.PlotSampler(plot_domain=square, n_points=640, device='cuda')\n", "fig = tp.utils.plot(model, lambda u : u, plot_sampler, plot_type='contour_surface')" @@ -359,14 +420,27 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We can plot the error, since we know the exact solution:" + "We can also plot the error, since we know the exact solution:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "def plot_fn(u, x):\n", " exact = torch.sin(np.pi/2*x[:, :1])*torch.cos(2*np.pi*x[:, 1:])\n", @@ -378,8 +452,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now you know how to solve a PDE in TorchPhysics, additional examples can \n", - "be found under the [example-folder](https://github.com/boschresearch/torchphysics/tree/main/examples)." + "Now you saw the basics on solbing a PDE in TorchPhysics, additional examples can \n", + "be found under the [example-folder](https://github.com/boschresearch/torchphysics/tree/main/examples).\n", + "\n", + "More in-depth information can be found in the [tutorial](https://torchphysics.readthedocs.io/en/latest/tutorial/tutorial_start.html)." ] } ], @@ -402,7 +478,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.9.15 (main, Nov 4 2022, 16:13:54) \n[GCC 11.2.0]" }, "orig_nbformat": 4 }, diff --git a/examples/tutorial/solve_pde_drm.ipynb b/examples/tutorial/solve_pde_drm.ipynb new file mode 100644 index 00000000..e9cd6bb7 --- /dev/null +++ b/examples/tutorial/solve_pde_drm.ipynb @@ -0,0 +1,485 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Solving a simple PDE with the DeepRitz-approach\n", + "===========================================\n", + "Here we give a beginner-friendly introduction to TorchPhysics, going over all the basic concepts and steps. For a more in-depth explanation, we recommend the [tutorial page](https://torchphysics.readthedocs.io/en/latest/tutorial/tutorial_start.html).\n", + "We introduce the library with the aim to solve the following PDE:\n", + "\n", + "\\begin{align*}\n", + "-\\Delta u &= 4.25\\pi^2 u \\text{ in } \\Omega = [0, 1] \\times [0, 1] \\\\\n", + "u &= \\sin(\\tfrac{\\pi}{2} x_1)\\cos(2\\pi x_2) \\text{ on } \\partial \\Omega\n", + "\\end{align*}\n", + "\n", + "For comparison, the analytic solution is $u(x_1, x_2) = \\sin(\\tfrac{\\pi}{2} x_1)\\cos(2\\pi x_2)$.\n", + "\n", + "Generally, the first step is to define all appearing variables and giving them a *name*. In TorchPhysics all input variables are considered as variables that have to be named, but also the solution functions. \n", + "From a mathematical point of view we essentially define to what ``space`` these variables *belong* (for example $x \\in \\mathbb{R}^2$). From a more applied point, we just set the name and dimension of our input and output values:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n", + "import torchphysics as tp \n", + "X = tp.spaces.R2('x') # input is 2D and named x\n", + "U = tp.spaces.R1('u') # output is 1D and named u" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next up is the domain, in our case a simple square. There are a lot of different domains provided in TorchPhysics (even logical operations and time dependencies are possible), these will be introduced further later in the tutorial and can be found under the section ``domains``. \n", + "\n", + "Usually a domain gets as an input the space it belongs to (here our 'x') and some different parameters that depend on the constructed object. For a parallelogram, for example the origin and two corners." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "square = tp.domains.Parallelogram(X, [0, 0], [1, 0], [0, 1])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we define our neural network, that we want to train. There are different architectures pre implemented, but since we build upon PyTorch one can easily define custom networks and use them.\n", + "\n", + "Generally, the DeepRitz approach uses a ResNet structure with cubic ReLU functions as an activation. In TorchPhysics all classes that handle the networks are collected under the ``models`` section. And the standard DeepRitz net is called ``DeepRitzNet``." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "model = tp.models.DeepRitzNet(input_space=X, output_space=U, width=50, depth=3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next step is the definition of the training conditions. Here we transform our PDE into some residuals that we minimize in the training. From an implementation point, we stay close to the original (mathematical) PDE and to the standard DeepRitz approach.\n", + "\n", + "Here we have two different conditions that the network should fulfill, the differential\n", + "equation itself and the boundary condition. Here, we start with the boundary condition:\n", + "\n", + " - For this, one has to first define a Python-function, that describes our trainings condition. \n", + " As an input, one can pick all variables and networks that appear in the problem and were defined \n", + " previously, via the ``spaces``. The output should describe how well the considered condition is fulfilled. \n", + " In our example, we just compute the expected boundary values and return the difference to the current network output. Here, ``u`` will already be the network evaluated at the points ``x`` (a batch of coordinates). Internally, this will then be transformed automatically to the integral-loss (which can also be customized, if needed) of the DeepRitz-method.\n", + " - We also need to tell on which points this condition should be fulfilled. For this TorchPhysics provides\n", + " the ``samplers`` section. Where different sampling strategies are implemented. \n", + " For the boundary condition we only need points at the boundary, in TorchPhysics all domains have the property ``.boundary`` that returns the boundary as a new domain-object. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "# Frist the function that defines the residual:\n", + "def bound_residual(u, x):\n", + " bound_values = torch.sin(np.pi/2*x[:, :1]) * torch.cos(2*np.pi*x[:, 1:])\n", + " return (u - bound_values)**2\n", + "\n", + "# the point sampler:\n", + "# here we use grid points, but any other sampler could also be used\n", + "bound_sampler = tp.samplers.RandomUniformSampler(square.boundary, n_points=50000)\n", + "#bound_sampler = bound_sampler.make_static() # grid always the same, therfore static for one single computation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once all this is defined, we have to combine the residual and sampler in a ``condition``. These condition handle internally the training process. Under the hood, they have the following simplified behavior (while training):\n", + "\n", + " 1) Sample points with the given sampler\n", + " 2) Evaluate model at these points\n", + " 3) Plug points and model output into the given residual \n", + " 4) Compute corresponding loss term\n", + " 5) Pass loss to the optimizer\n", + "\n", + "In TorchPhysics many different condition types are pre implemented (for including data, integral conditions, etc.). Here we use the DeepRitz approach, which corresponds to a ``DeepRitzCondition``:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "bound_cond = tp.conditions.DeepRitzCondition(module=model, sampler=bound_sampler, \n", + " integrand_fn=bound_residual, weight=50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The same holds for the differential equation term. Here also different operators are implemented, that help to compute the derivatives of the neural network. They can be found under the ``utils`` section. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Again a function that defines the residual:\n", + "def energy_residual(u, x):\n", + " grad_term = torch.sum(tp.utils.grad(u, x)**2, dim=1, keepdim=True)\n", + " out = 0.5*(grad_term - 4.25*np.pi**2 * u*torch.sin(np.pi/2*x[:, :1]) * torch.cos(2*np.pi*x[:, 1:]))\n", + " return out\n", + "\n", + "# the point sampler, for the trainig points:\n", + "pde_sampler = tp.samplers.RandomUniformSampler(square, n_points=120000) \n", + "pde_sampler = pde_sampler.make_static(resample_interval=30)\n", + "# wrap everything together in the condition\n", + "pde_cond = tp.conditions.DeepRitzCondition(module=model, sampler=pde_sampler, \n", + " integrand_fn=energy_residual, weight=1.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The transformation of our PDE into a TorchPhysics problem is finished. So we can start the\n", + "training.\n", + "\n", + "The last step before the training is the creation of a ``Solver``. This is an object that inherits from\n", + "the Pytorch Lightning *LightningModule*. It handles the training and validation loops and takes care of the\n", + "data loading for GPUs or CPUs. It gets the following inputs:\n", + "\n", + "- train_conditions: A list of all train conditions\n", + "- val_conditions: A list of all validation conditions (optional)\n", + "- optimizer_setting: With this, one can specify what optimizers, learning, and learning-schedulers \n", + " should be used. For this, there exists the class *OptimizerSetting* that handles all these parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# here we start with Adam:\n", + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.0001)\n", + "\n", + "solver = tp.solver.Solver(train_conditions=[bound_cond, pde_cond], optimizer_setting=optim)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we define the trainer, for this we use Pytorch Lightning. Almost all functionalities of\n", + "Pytorch Lightning can be applied in the trainings process." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [1]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 15.5 K\n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "15.5 K Trainable params\n", + "0 Non-trainable params\n", + "15.5 K Total params\n", + "0.062 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "53c01cb1c239447bbbd11eaa99727ab6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "077a043baa244c7382178cbef10025a7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "71f40add9973460a9f279ae1657eebae", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pytorch_lightning as pl\n", + "## maybe selcet the GPU to use:\n", + "#import os\n", + "#os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n", + "\n", + "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", + " max_steps=2500, # number of training steps\n", + " logger=False,\n", + " benchmark=True,\n", + " checkpoint_callback=False)\n", + " \n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we want to have a look on our solution, we can use the plot-methods of TorchPhysics:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [1]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 15.5 K\n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "15.5 K Trainable params\n", + "0 Non-trainable params\n", + "15.5 K Total params\n", + "0.062 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6cce7463816e4a4ead8127108c67d2a5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "acb322a9cc9447cfb177fb92aa404aed", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "00f43386ada4408ab86c7cd3153a75d7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.LBFGS, lr=0.05, \n", + " optimizer_args={'max_iter': 2, 'history_size': 100})\n", + "\n", + "bound_cond.sampler = bound_cond.sampler.make_static() \n", + "pde_cond.sampler = pde_cond.sampler.make_static()# LBFGS can not work with varing points!\n", + "solver = tp.solver.Solver(train_conditions=[bound_cond, pde_cond], optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " max_steps=1000, # number of training steps\n", + " logger=False,\n", + " benchmark=True,\n", + " checkpoint_callback=False)\n", + " \n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/torch/functional.py:478: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:2895.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n", + "/home/tomfre/Desktop/torchphysics/src/torchphysics/problem/domains/domain2D/parallelogram.py:134: UserWarning: The use of `x.T` on tensors of dimension other than 2 to reverse their shape is deprecated and it will throw an error in a future release. Consider `x.mT` to transpose batches of matricesor `x.permute(*torch.arange(x.ndim - 1, -1, -1))` to reverse the dimensions of a tensor. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:2985.)\n", + " bary_coords = torch.stack(torch.meshgrid((x, y))).T.reshape(-1, 2)\n", + "/home/tomfre/Desktop/torchphysics/src/torchphysics/utils/plotting/plot_functions.py:416: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:204.)\n", + " embed_point = Points(torch.tensor([center]), domain.space)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_sampler = tp.samplers.PlotSampler(plot_domain=square, n_points=640, device='cuda')\n", + "fig = tp.utils.plot(model, lambda u : u, plot_sampler, plot_type='contour_surface')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also plot the error, since we know the exact solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def plot_fn(u, x):\n", + " exact = torch.sin(np.pi/2*x[:, :1])*torch.cos(2*np.pi*x[:, 1:])\n", + " return torch.abs(u - exact)\n", + "fig = tp.utils.plot(model, plot_fn, plot_sampler, plot_type='contour_surface')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now you saw the basics on solbing a PDE in TorchPhysics, additional examples can \n", + "be found under the [example-folder](https://github.com/boschresearch/torchphysics/tree/main/examples).\n", + "\n", + "More in-depth information can be found in the [tutorial](https://torchphysics.readthedocs.io/en/latest/tutorial/tutorial_start.html)." + ] + } + ], + "metadata": { + "interpreter": { + "hash": "fb770cb910411e790a99fd848f827dc995ac53be5098d939fbaa56bcec3c9277" + }, + "kernelspec": { + "display_name": "Python 3.9.4 64-bit ('bosch': conda)", + "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.15 (main, Nov 4 2022, 16:13:54) \n[GCC 11.2.0]" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From b83211154f225fd14521602c0b4055d0f85024cb Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Wed, 18 Jan 2023 15:33:57 +0100 Subject: [PATCH 05/30] Update read me, to include all current approaches Signed-off-by: Tom Freudenberg --- README.rst | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/README.rst b/README.rst index 673e893b..5c94db52 100644 --- a/README.rst +++ b/README.rst @@ -9,13 +9,15 @@ You can use TorchPhysics e.g. to - train a neural network to approximate solutions for different parameters - solve inverse problems and interpolate external data -The following approaches are implemented using high-level concepts to make their usage as easy as possible: +The following approaches are implemented using high-level concepts to make their usage as easy +as possible: - physics-informed neural networks (PINN) [1]_ - QRes [2]_ - the Deep Ritz method [3]_ +- DeepONets [4]_ and Physics-Informed DeepONets [5]_ -TorchPhysics can also be used to implement extensions of these approaches or concepts like DeepONets [4]_ and Physics-Informed DeepONets [5]_. We aim to also include further implementations in the future. +We aim to also include further implementations in the future. TorchPhysics is build upon the machine learning library PyTorch_. From 0d009f174dc8bb1e1b8bdbab3aabb56a3c0293f0 Mon Sep 17 00:00:00 2001 From: kenaj123 <126678830+kenaj123@users.noreply.github.com> Date: Wed, 1 Mar 2023 13:46:22 +0100 Subject: [PATCH 06/30] Main PINNs Tutorial MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Janek Gödeke --- .../PINNs_Tutorial_Introduction.ipynb | 1016 +++++++++++++++++ 1 file changed, 1016 insertions(+) create mode 100644 examples/tutorial/PINNs_Tutorial_Introduction.ipynb diff --git a/examples/tutorial/PINNs_Tutorial_Introduction.ipynb b/examples/tutorial/PINNs_Tutorial_Introduction.ipynb new file mode 100644 index 00000000..7061741f --- /dev/null +++ b/examples/tutorial/PINNs_Tutorial_Introduction.ipynb @@ -0,0 +1,1016 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "1ef6d147-2dd4-4547-9fb6-79b3758d7350", + "metadata": {}, + "outputs": [], + "source": [ + "import torchphysics as tp\n", + "import numpy as np\n", + "import torch\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "7cf51978-f0cb-4331-ba1c-9ee4ca6bf8f0", + "metadata": {}, + "source": [ + "# Physics Informed Neural Networks (PINNs) in TorchPhysics\n", + "In this tutorial we present a first basic example of solving a PDE with boundary constraints in TorchPhysics using a PINN approach.\n", + "You will also learn about the different components of this library and main steps for finding a neural network that approximates the solution of a PDE. \n", + "\n", + "We want to solve the time-dependent heat equation for a perfectly insulated room $\\Omega\\subset \\mathbb{R}^2$ in which a heater is turned on. \n", + "$$\n", + "\\begin{cases}\n", + "\\frac{\\partial}{\\partial t} u(x,t) &= \\Delta_x u(x,t) &&\\text{ on } \\Omega\\times I, \\\\\n", + "u(x, t) &= u_0 &&\\text{ on } \\Omega\\times \\{0\\},\\\\\n", + "u(x,t) &= h(t) &&\\text{ at } \\partial\\Omega_{heater}\\times I, \\\\\n", + "\\nabla_x u(x, t) \\cdot \\overset{\\rightarrow}{n}(x) &= 0 &&\\text{ at } (\\partial \\Omega \\setminus \\partial\\Omega_{heater}) \\times I.\n", + "\\end{cases}\n", + "$$\n", + "The initial room (and heater) temperature is $u_0 = 16$. The time domain is the interval $I = (0, 20)$, whereas the domain of the room is $\\Omega=(5,0) \\times (4,0)$. The heater is located at $\\partial\\Omega_{heater} = [1,3] \\times \\{4\\}$ and the temperature of the heater is described by the function $h$ defined below.\n", + "The normal vector at some $x\\in \\partial \\Omega$ is denoted by $\\overset{\\rightarrow}{n}(x)$." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d6b5fdd2-67c1-4f7e-a185-9d515fb9f3f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "u_0 = 16 # initial temperature\n", + "u_heater_max = 40 # maximal temperature of the heater\n", + "t_heater_max = 5 # time at which the heater reaches its maximal temperature\n", + "\n", + "# heater temperature function\n", + "def h(t):\n", + " ht = u_0 + (u_heater_max - u_0) / t_heater_max * t\n", + " ht[t>t_heater_max] = u_heater_max\n", + " return ht\n", + "\n", + "# Visualize h(t)\n", + "t = np.linspace(0, 20, 200)\n", + "plt.plot(t, h(t))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8da6279e-83c2-41ed-a56b-453b21f05d11", + "metadata": {}, + "source": [ + "# Recall PINNs\n", + "The goal is to find a neural network $u_\\theta: \\overline{\\Omega\\times I} \\to \\mathbb{R}$, which approximately satisfies all four conditions of the PDE problem above, where $\\theta$ are the trainable parameters of the neural network.\n", + "Let us shortly recall the main idea behind PINNs.\n", + "\n", + "In our case, there is no data available (e.g. temperature measurements in $\\Omega$), which could be used for training the neural network. Hence, we can only exploit the four conditions listed above.\n", + "\n", + "The residuals are denoted by \n", + "$$\n", + "\\begin{align}\n", + "&\\text{1) Residual of pde condition: } &&R_1(u, x, t) := u(x, t) - \\Delta_x u(x,t) \\\\\n", + "&\\text{2) Residual of initial condition: } &&R_2(u, x) := u(x, 0) - u_0\\\\\n", + "&\\text{3) Residual of dirichlet boundary condition: } &&R_3(u, x, t) := u(x,t) - h(t)\\\\\n", + "&\\text{4) Residual of neumann boundary condition: } &&R_4(u, x, t) :=\\nabla_x u(x,t) \\cdot \\overset{\\rightarrow}{n}(x)\n", + "\\end{align}\n", + "$$\n", + "Continuing with the PINN approach, points are sampled in the domains corresponding to each condition. In our example points\n", + "$$\n", + "\\begin{align}\n", + "&\\text{1) } &&\\big(x^{(1)}_i, t_i^{(1)} \\big)_i &&&\\in \\Omega \\times I,\\\\\n", + "&\\text{2) } &&\\big(x^{(2)}_j, 0 \\big)_j &&&\\in \\Omega \\times \\{0\\},\\\\\n", + "&\\text{3) } &&\\big(x^{(3)}_k, t_k^{(3)} \\big)_k &&&\\in \\partial\\Omega_{heater} \\times I,\\\\\n", + "&\\text{4) } &&\\big(x^{(4)}_l, t_l^{(4)} \\big)_l &&&\\in (\\partial\\Omega \\setminus \\partial\\Omega_{heater}) \\times I.\n", + "\\end{align}\n", + "$$\n", + "Then, the network $u_\\theta$ is trained by solving the following minimization problem\n", + "$$\n", + "\\begin{align}\n", + "\\min_\\theta \\sum_{i} \\big\\vert R_1(u_\\theta, x^{(1)}_i, t_i^{(1)}) \\big \\vert^2\n", + "+ \\sum_j \\big\\vert R_2(u_\\theta, x^{(2)}_j) \\big \\vert^2\n", + "+ \\sum_k \\big\\vert R_3(u_\\theta, x^{(3)}_k, t_k^{(3)}) \\big \\vert^2\n", + "+ \\sum_l \\big\\vert R_4(u_\\theta, x^{(4)}_l, t_l^{(4)}) \\big \\vert^2,\n", + "\\end{align}\n", + "$$\n", + "that is, the residuals are minimized with respect to the $l_2$-norm.\n", + "It is to be noted here that if data was available, one could simply add a data loss term to the loss function above." + ] + }, + { + "cell_type": "markdown", + "id": "8f0db4a0-cace-4d21-845f-f34680880d7d", + "metadata": {}, + "source": [ + "# Translating the PDE Problem into the Language of TorchPhysics\n", + "Translating the PDE problem into the framework of TorchPhysics works in a convenient and intuitive way, as the notation is close to the mathematical formulation. The general procedure can be devided into five steps. Also when solving other problems with TorchPhysics, such as parameter identification or variational problems, the same steps can be applied, see also the further tutorials or examples (REFERENCE)." + ] + }, + { + "cell_type": "markdown", + "id": "e8fe0433-82b7-4093-8f6f-8adf7e46ff5b", + "metadata": {}, + "source": [ + "### Step 1: Specify spaces and domains\n", + "The spatial domain $\\Omega$ is a subset of the space $\\mathbb{R}^2$, the time domain $I$ is a subset of $\\mathbb{R}$, whereas the temperature $u(x,t)$ attains values in $\\mathbb{R}$. First, we need to let TorchPhysics know which spaces and domains we are dealing with and how variables/elements within these spaces are denoted by.\n", + "This is realized by generating objects of TorchPhysics' Space and Domain classes in \"tp.spaces\" and \"tp.domains\", respectively. \n", + "Some simple domains are already predefined, which will be sufficient for this tutorial. For creating complexer domains please have a look at the (REFERENCE DOMAIN-TUTORIAL)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6af0dba0-d481-4566-a8b7-244098eee713", + "metadata": {}, + "outputs": [], + "source": [ + "# Input and output spaces\n", + "X = tp.spaces.R2(variable_name='x')\n", + "T = tp.spaces.R1('t')\n", + "U = tp.spaces.R1('u')\n", + "\n", + "# Domains\n", + "Omega = tp.domains.Parallelogram(space=X, origin=[0,0], corner_1=[5,0], corner_2=[0,4])\n", + "I = tp.domains.Interval(space=T, lower_bound=0, upper_bound=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1efe92cb-daab-4d21-8a43-5008e3e9248a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# The domain can be visualized by creating a sampler object, see also step 2, and use the scatter plot function from tp.utils. \n", + "Omega_sampler = tp.samplers.RandomUniformSampler(Omega, n_points=1000)\n", + "plot = tp.utils.scatter(X, Omega_sampler)" + ] + }, + { + "cell_type": "markdown", + "id": "a1676bc3-8dab-4ce4-84ff-f8fc29e8b829", + "metadata": {}, + "source": [ + "### Step 2: Define point samplers for different subsets of $\\overline{\\Omega\\times I}$\n", + "As mentioned in the PINN recall, it will be necessary to sample points in different subsets of the full domain $\\overline{\\Omega\\times I}$. TorchPhysics provides this functionality by sampler classes in \"tp.samplers\". For simplicity, we consider only Random Uniform Samplers for the subdomains. However, there are many more possibilities to sample points in TorchPhysics, see also (REFERENCE SAMPLER-TUTORIAL).\n", + "\n", + "The most important inputs of a sampler constructor are the \"domain\" from which points will be sampled, as well as the \"number of points\" drawn every time the sampler is called. It is reasonable to create different sampler objects for the different conditions of the pde problem, simply because the subdomains differ.\n", + "\n", + "For instance, the pde condition 1) should hold for points in the domain $\\Omega \\times I$. We have already created $\\Omega$ and $I$ as TorchPhysics Domains in Step 1. Their cartesian product is simply obtained by the multiplication operator \"$*$\":" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d428cf7f-89ee-4f3f-a1bf-822b82550a7e", + "metadata": {}, + "outputs": [], + "source": [ + "domain_pde_condition = Omega * I" + ] + }, + { + "cell_type": "markdown", + "id": "8db04580-edb8-45ac-8f48-091450647377", + "metadata": {}, + "source": [ + "Having the relevant domain on hand, we initialize as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d020f7f4-c286-466f-928d-1f80ee64c53f", + "metadata": {}, + "outputs": [], + "source": [ + "sampler_pde_condition = tp.samplers.RandomUniformSampler(domain=domain_pde_condition, n_points=15000)" + ] + }, + { + "cell_type": "markdown", + "id": "ac69b667-1a77-4e8a-8a20-2e0b5a1de2a0", + "metadata": {}, + "source": [ + "There is an important alternative way of creating a sampler for a cartesian product of domains. Instead of defining the sampler on $\\Omega\\times I$, it is also possible to create samplers on $\\Omega$ and $I$ seperately, and multiply the samplers instead. This might be useful if different resolutions shall be considered, or when using other samplers in TorchPhysics such as a GridSampler, since a GridSampler cannot directly be created on a cartesian product in the way above." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3a1ee851-1bd4-4ee2-83e4-7dca3f883c0f", + "metadata": {}, + "outputs": [], + "source": [ + "sampler_Omega = tp.samplers.GridSampler(domain=Omega, n_points=10000)\n", + "sampler_I = tp.samplers.RandomUniformSampler(domain=I, n_points=5000)\n", + "alternative_sampler_pde_condition = sampler_Omega * sampler_I " + ] + }, + { + "cell_type": "markdown", + "id": "c9f72b70-0e87-466f-a7c0-0e1f194745cc", + "metadata": {}, + "source": [ + "For more detailed information on the functionality of TorchPysics samplers, please have a look at (REFERENCE EXAMPLES & SAMPLER-TUTORIAL)\n", + "\n", + "Next, let us define samplers for the initial and boundary conditions. Regarding the initial condition the domain is $\\Omega \\times \\{0\\}$, so we need access to the left boundary of the time interval $I$. All tp.domains.Interval objects have the attribute \"left_boundary\", an instance of TorchPhysics BoundaryDomain class, a subclass of the Domain class." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e780f5fa-5ebf-4731-8568-77116ea039f6", + "metadata": {}, + "outputs": [], + "source": [ + "domain_initial_condition = Omega * I.boundary_left\n", + "sampler_initial_condition = tp.samplers.RandomUniformSampler(domain_initial_condition, 5000)" + ] + }, + { + "cell_type": "markdown", + "id": "7750bf6b-30ec-4ca9-8f37-9699439d0d22", + "metadata": {}, + "source": [ + "Both the Dirichlet and Neumann boundary conditions should hold on subsets of the boundary $\\partial \\Omega \\times I$. It is easier to use a sampler for the whole boundary and determine later (in Step 3, the definition of the residual functions) whether a sampled point belongs to the domain $\\partial \\Omega_{heater}\\times I$ of the Dirichlet condition, or to the domain $(\\partial \\Omega \\setminus \\partial \\Omega_{heater}) \\times I$ of the Neumann condition." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b627951a-a12b-4333-b965-35a56b8fc396", + "metadata": {}, + "outputs": [], + "source": [ + "domain_boundary_condition = Omega.boundary * I\n", + "sampler_boundary_condition = tp.samplers.RandomUniformSampler(domain_boundary_condition, 5000)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c23a19e6-4167-4785-8323-984c319e2cb4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# TODO: Plot at two or three times\n", + "plot = tp.utils.scatter(X, sampler_boundary_condition)" + ] + }, + { + "cell_type": "markdown", + "id": "6b1b87f9-b6d6-44ec-8fb5-833ab466d89b", + "metadata": {}, + "source": [ + "### Step 3: Define residual functions\n", + "As mentioned in the PINNs Recall, we are looking for a neural network $u_\\theta$ for which all of the residual functions $R_1,...,R_4$ vanish.\n", + "\n", + "Let us have a look at $R_1$, the residual for the pde condition, the way it is defined in the PINNs Recall above. The inputs of $R_1$ are spatial and temporal coordinates $x\\in \\Omega$, $t\\in I$, but also the temperature $u_\\theta$, which is itself a function of $x$ and $t$. In TorchPhysics, the evaluation of the network $u_\\theta$ at $(x,t)$ is done before evaluating the residual functions. This means that from now on we consider $R_1$ as well as the other residuals to be functions, whose inputs are triples $(u, x, t)$, where $u:=u_\\theta(x,t)$.\n", + "\n", + "More precisely, $u$ will be a torch.tensor of shape (n_points, 1), $x$ of shape (n_points, 2) and $t$ of shape (n_points, 1), where n_points is the number of triples $(u,x,t)$ for which the residual should be computed.\n", + "\n", + "For the residual $R_1$ it is required to compute the laplacian of $u$ with respect to $x$, as well as the gradient with respect to $t$. These differential operators, among others - see (REFERENCE UTILS-TUTORIAL), are pre-implemented and can be found in \"tp.utils\". The intern computation is build upon torch's autograd functionality." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c29f3f92-d613-470f-ab74-9369e071ea04", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_pde_condition(u, x, t):\n", + " return tp.utils.laplacian(u, x) - tp.utils.grad(u, t)" + ] + }, + { + "cell_type": "markdown", + "id": "e444a2e5-6fc6-4124-894c-1ba987153241", + "metadata": {}, + "source": [ + "For the computation of the residual $R_2$ of the initial condition, the coordinates $x$ and $t$ are not required, since $u$ is already the evaluation of the network at these points. Therefore, we can conveniently omit them as input parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "65954de9-4c80-4d2a-be6e-0cd16ab82596", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_initial_condition(u):\n", + " return u - u_0" + ] + }, + { + "cell_type": "markdown", + "id": "97b9bfba-5cd3-400c-8c5a-4cd48b320c80", + "metadata": {}, + "source": [ + "In Step 2, we defined a boundary sampler for $\\partial \\Omega \\times I$, the domain for the boundary conditions. Hence, the sampler does not differ between the domain of the Dirichlet and Neumann boundary conditions. This is why we define a combined residual function $R_b$ for $R_3$ and $R_4$, which will output\n", + "$$\n", + "\\begin{align}\n", + "R_b(u, x, t) = \\begin{cases}\n", + "R_3(u, x, t) &\\text{ if } &&x \\in \\partial \\Omega_{heater},\\\\\n", + "R_4(u, x, t) &\\text{ if } &&x \\in \\partial \\Omega \\setminus \\partial \\Omega_{heater}.\n", + "\\end{cases}\n", + "\\end{align}\n", + "$$\n", + "Let us start with the defintion of the Dirichlet residual $R_3$:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c97e8bfe-1580-4bb8-bb1b-d4c874ef6244", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_dirichlet_condition(u, t):\n", + " return u - h(t)" + ] + }, + { + "cell_type": "markdown", + "id": "de441693-0870-43db-8d8d-38777a075432", + "metadata": {}, + "source": [ + "For the Neumann residual $R_4$ we need the normal derivative of $u$ at $x$. This differential operator is also contained in \"tp.utils\", whereas the normal vectors at points $x\\in \\partial \\Omega$ are available by the attribute \"normal\" of the \"boundary\" of the domain $\\Omega$." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "17d5e293-57bd-4739-9518-a014f6df2b79", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_neumann_condition(u, x):\n", + " normal_vectors = Omega.boundary.normal(x)\n", + " normal_derivative = tp.utils.normal_derivative(u, normal_vectors, x)\n", + " return normal_derivative " + ] + }, + { + "cell_type": "markdown", + "id": "463e507e-d33b-4f8d-9149-c45356fdf236", + "metadata": {}, + "source": [ + "The combined boundary residual $R_b$ is then easily obtained as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "4864c6ed-6f2b-4f80-bd6f-cd8ff3d8a809", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_boundary_condition(u, x, t):\n", + " # Create boolean tensor indicating which points x belong to the dirichlet condition (heater location)\n", + " heater_location = (x[:, 0] >= 1 ) & (x[:, 0] <= 3) & (x[:, 1] >= 3.99) \n", + " # First compute Neumann residual everywhere, also at the heater position\n", + " residual = residual_neumann_condition(u, x)\n", + " # Now change residual at the heater to the Dirichlet residual\n", + " residual_h = residual_dirichlet_condition(u, t)\n", + " residual[heater_location] = residual_h[heater_location]\n", + " return residual" + ] + }, + { + "cell_type": "markdown", + "id": "0cc89ada-310b-4a84-bcc0-77baa7afca2c", + "metadata": {}, + "source": [ + "### Step 4: Define Neural Network\n", + "At this point, let us define the model $u_\\theta:\\overline{\\Omega\\times I}\\to \\mathbb{R}$. This task is handled by the TorchPhysics Model class, which is contained in \"tp.models\". It inherits from the torch.nn.Module class from Pytorch, which means that building own models can be achieved in a very similar way, see (REFERENCE MODEL-TUTORIAL).\n", + "There are also a bunch of predefined neural networks or single layers available, e.g. fully connected networks (FCN) or normalization layers, which are subclasses of TorchPhysics' Model class. \n", + "In this tutorial we consider a very simple neural network, constructed in the following way:\n", + "\n", + "We start with a normalization layer, which maps points $(x,t)\\in \\overline{\\Omega\\times I}\\subset \\mathbb{R}^3$ into the cube $[-1, 1]^3$." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "bdef3d80-90e6-47aa-95ce-6d735fd03f36", + "metadata": {}, + "outputs": [], + "source": [ + "normalization_layer = tp.models.NormalizationLayer(Omega*I)" + ] + }, + { + "cell_type": "markdown", + "id": "75e0d506-13f0-4e39-882b-d752c89fe7fc", + "metadata": {}, + "source": [ + "Afterwards, the scaled points will be passed through a fully connected network. The constructor requires to include the input space $X\\times T$, output space $U$ and ouput dimensions of the hidden layers. Remember the definition of the TorchPyhsics spaces $X,T$ and $U$ from Step 1. Similar as for domains, the cartesian product of spaces is obtained by the multiplication operator \"$*$\". Here, we consider a fully connected network with four hidden layers, the latter consisting of $80, 50, 50$ and $50$ neurons, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "fa15606a-a2c7-40bf-9e41-920c8f6a1bc9", + "metadata": {}, + "outputs": [], + "source": [ + "fcn_layer = tp.models.FCN(input_space=X*T, output_space=U, hidden = (80,50,50,50))" + ] + }, + { + "cell_type": "markdown", + "id": "694d8666-170e-4c28-a87a-73aa329e2094", + "metadata": {}, + "source": [ + "Similar to Pytorch, the normalization layer and FCN can be concatenated by the class \"tp.models.Sequential\":" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9b838d6f-1b90-4667-8ecb-9f54b4ec627e", + "metadata": {}, + "outputs": [], + "source": [ + "model = tp.models.Sequential(normalization_layer, fcn_layer)" + ] + }, + { + "cell_type": "markdown", + "id": "17e3f8ab-bd6c-4f4f-94a6-030930458c0c", + "metadata": {}, + "source": [ + "### Step 5: Create TorchPhysics Conditions\n", + "Let us sum up what we have done so far: For the pde, initial and combined boundary condition of the PDE problem, we constructed samplers and residuals on the corresponding domains.\n", + "Moreover, we have defined a neural network which will later be trained to fulfull each of these conditions.\n", + "\n", + "As a final step, we collect these constructions for each condition in an object of the TorchPhysics Condition class, contained in \"tp.conditions\". \n", + "Since we are interested in applying a PINN approach, we create objects of the subclass PINNCondition, which automatically contains the information that the residuals should be minimized in the squared $l_2$-norm, see again the PINN Recall. For other TorchPhysics Conditions one may need to specify which norm should be taken of the residuals, see (REFERENCE CONDITION-TUTORIAL) for further information." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "008c09a7-81f8-41b5-8c10-3892812740ad", + "metadata": {}, + "outputs": [], + "source": [ + "pde_condition = tp.conditions.PINNCondition(module =model, \n", + " sampler =sampler_pde_condition,\n", + " residual_fn=residual_pde_condition)\n", + "\n", + "initial_condition = tp.conditions.PINNCondition(module =model, \n", + " sampler =sampler_initial_condition,\n", + " residual_fn=residual_initial_condition)\n", + "\n", + "boundary_condition = tp.conditions.PINNCondition(module =model, \n", + " sampler =sampler_boundary_condition,\n", + " residual_fn=residual_boundary_condition)" + ] + }, + { + "cell_type": "markdown", + "id": "5cd77316-3c78-4bf1-b639-9ccb7070af2d", + "metadata": {}, + "source": [ + "It is to be noted that TorchPhysics' Condition class is a subclass of the torch.nn.Module class and its forward() method returns the current loss of the respective condition.\n", + "For example, calling forward() of the pde_condition at points $(x_i, t_i)_i$ in $\\Omega\\times I$ will return\n", + "$$\n", + "\\begin{align}\n", + "\\sum_i \\big \\vert R_1(u_\\theta, x_i, t_i) \\big \\vert^2,\n", + "\\end{align}\n", + "$$\n", + "where $R_1$ is the residual function for the pde condition defined in the PINN recall and $u_\\theta$ is the model defined in Step 4." + ] + }, + { + "cell_type": "markdown", + "id": "2e0fad4c-2cfd-4c10-8e2f-0a3702a2eeac", + "metadata": {}, + "source": [ + "The reason that also the model is required for initializing a Condition object is, that it could be desireable in some cases to train different networks for different conditions of the PDE problem. (TODO: EXAMPLE?)" + ] + }, + { + "cell_type": "markdown", + "id": "31d80c43-5879-401c-8212-0e4a5fd6514c", + "metadata": {}, + "source": [ + "# Training based on Pytorch Lightning \n", + "In order to train a model, TorchPhysics makes use of the Pytorch Lightning library, which hence must be imported. Further, we import \"os\" so that GPUs can be used for the calculations." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "bb76e892-bf53-4a01-adc5-74dddb770525", + "metadata": {}, + "outputs": [], + "source": [ + "import pytorch_lightning as pl\n", + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\" # select GPUs to use" + ] + }, + { + "cell_type": "markdown", + "id": "1639cf38-835b-4571-b0c5-7ef0d130c2df", + "metadata": {}, + "source": [ + "For the training process, i.e. the minimization of the loss function introduced in the PINN recall, TorchPhysics provides the Solver class. It inherits from the pl.LightningModule class and is compatible with the TorchPhysics library. The constructor requires a list of TorchPhysics Conditions, whose parameters should be optimized during the training." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "ea27b608-e319-4fac-85c1-5984f2d043c6", + "metadata": {}, + "outputs": [], + "source": [ + "training_conditions = [pde_condition, initial_condition, boundary_condition]" + ] + }, + { + "cell_type": "markdown", + "id": "e024913e-e10e-4387-b390-165e77c8524b", + "metadata": {}, + "source": [ + "By default, the Solver uses the Adam Optimizer from Pytorch with learning rate $lr=0.001$ for optimizing the training_conditions. If a different optimizer or choice of its arguments shall be used, one can collect these information in an object of TorchPhysics' OptimizerSetting class. Here we choose the Adam Optimizer from Pytorch with a learning rate $lr=0.002$." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "b1848d26-ea33-400c-84be-2291429e8065", + "metadata": {}, + "outputs": [], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.0005)" + ] + }, + { + "cell_type": "markdown", + "id": "efcd0c8c-1ef2-45a0-bf00-de88201f3d03", + "metadata": {}, + "source": [ + "Finally, we are able to create the Solver object, a Pytorch Lightning Module." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "4ea2cb3f-087c-4e03-aeb0-40318f556062", + "metadata": {}, + "outputs": [], + "source": [ + "solver = tp.solver.Solver(train_conditions=training_conditions, optimizer_setting=optim)" + ] + }, + { + "cell_type": "markdown", + "id": "53dec402-5dd2-40f9-a405-5170d0cfcbd7", + "metadata": {}, + "source": [ + "Now, as usual, the training is done with a Pytorch Lightning Trainer object and its fit() method." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "9ea9431a-9ea4-4312-8869-af4c8c4733a4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 9.5 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "9.5 K Trainable params\n", + "0 Non-trainable params\n", + "9.5 K Total params\n", + "0.038 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a050f77d9e2d482da29dd2227d5ab966", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Start the training\n", + "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", + " max_steps=1000, # number of training steps\n", + " logger=False,\n", + " benchmark=True,\n", + " checkpoint_callback=False)\n", + "\n", + "trainer.fit(solver) # start training" + ] + }, + { + "cell_type": "markdown", + "id": "c2fa291a-73b1-476b-8302-3aa63c34c61a", + "metadata": {}, + "source": [ + "You can also re-run the last three blocks with a smaller learning rate to further decrease the loss.\n", + "\n", + "Of course, the state dictionary of the model can be saved in the common way: torch.save(model.state_dict(), 'sd')" + ] + }, + { + "cell_type": "markdown", + "id": "bac7c186-2be3-4ce0-a252-527ae5083019", + "metadata": {}, + "source": [ + "# Visualization\n", + "Torchphysics provides built-in functionalities for visualizing the outcome of the neural network.\n", + "As a first step, for the 2D heat equation example one might be interested in creating a contour plot for the heat distribution inside of the room at some fixed time.\n", + "\n", + "For this purpose, we use the plot() function from \"tp.utils\", which is built on the Matplotlib library. The most important inputs are:\n", + "1) model: The neural network whose output shall be visualized.\n", + "2) point_function: Will be applied to the model's output before visualization. E.g. if the output was two-dimensional, the plot_function $u\\mapsto u[:, 0]$ could be used for showing only its first coordinate.\n", + "3) plot_sampler: A sampler creating points the neural network will be evaluated at for creating the plot.\n", + "4) plot_type: Specify what kind of plot should be created. \n", + "\n", + "Let us start with the sampler. The samplers we have seen so far (RandomUniformSampler, GridSampler) plot either on the interior or the boundary of their domain.\n", + "However, it is desirable to consider both the interior and the boundary points in the visualization. For this, one can use a PlotSampler, which is desined for harmonizing with plotting duties.\n", + "\n", + "We wish to visualize the heat distribution in $\\overline{\\Omega}$ at some fixed time $t'$. The latter can be added to the attribute \"data_for_other_variables\" of the PlotSampler." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "00c3d1e0-aeda-4e15-9ca5-67bbb953bd73", + "metadata": {}, + "outputs": [], + "source": [ + "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=600, data_for_other_variables={'t':0.})" + ] + }, + { + "cell_type": "markdown", + "id": "5f9efe1d-cf26-4274-9ac0-1bba28e04827", + "metadata": {}, + "source": [ + "In our case, the model's output is a scalar and we do not want to modify it before plotting. Hence, plot_function should be the identity mapping. As we wish to use a colormap/contour plot to visualize the heat in $\\Omega$, we specify the plot_type as 'contour_surface'.\n", + "\n", + "Finally, we obtain the desired plot at time $t'=0$ by" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "3b514990-7c54-4896-b391-9275011df402", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/s_e8mv8u/anaconda3/envs/tp/lib/python3.9/site-packages/torchphysics/utils/plotting/plot_functions.py:416: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at /opt/conda/conda-bld/pytorch_1646756402876/work/torch/csrc/utils/tensor_new.cpp:210.)\n", + " embed_point = Points(torch.tensor([center]), domain.space)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "vmin = 15 # limits for the axes\n", + "vmax = 42\n", + "fig = tp.utils.plot(model =model, plot_function=lambda u : u, \n", + " point_sampler=plot_sampler, plot_type ='contour_surface',\n", + " vmin=vmin, vmax=vmin)" + ] + }, + { + "cell_type": "markdown", + "id": "54c7788a-d7a0-438c-821e-bef10f3f780f", + "metadata": {}, + "source": [ + "Let us visualize the solution of the PDE at further time points." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "e9e54d6e-f7a2-4746-a05e-681e3dbee8b7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=600, data_for_other_variables={'t':4.})\n", + "fig = tp.utils.plot(model, lambda u : u, \n", + " plot_sampler, plot_type='contour_surface',\n", + " vmin=vmin, vmax=vmax)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "10a7c785-90da-4b62-964f-af7d816ed1bd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=600, data_for_other_variables={'t':8.})\n", + "fig = tp.utils.plot(model, lambda u : u, \n", + " plot_sampler, plot_type='contour_surface',\n", + " vmin=vmin, vmax=vmax)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "c3e6a8cf-6bd5-42d6-a3ac-16c4a64eb22b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=600, data_for_other_variables={'t':12.})\n", + "fig = tp.utils.plot(model, lambda u : u, plot_sampler, plot_type='contour_surface',\n", + " vmin=vmin, vmax=vmax)" + ] + }, + { + "cell_type": "markdown", + "id": "9d58e206-c27f-4ee6-8f4d-ddb1415c7221", + "metadata": {}, + "source": [ + "It is also possible to evaluate the model manually at torch Tensors. Say, we want to evaluate it on a spatial grid at some fixed time $t'= 6$." + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "id": "9ccbb9b3-6f6a-4a29-8dc7-c2360b2df7c9", + "metadata": {}, + "outputs": [], + "source": [ + "x_coords = torch.linspace(0, 5, 100)\n", + "y_coords = torch.linspace(0, 4, 80)\n", + "t_coords = torch.linspace(6, 6 , 1)\n", + "#t_coords = torch.linspace(0, 20, 120)\n", + "xs, ys, ts = torch.meshgrid([x_coords, y_coords, t_coords])\n", + "tensors = torch.stack([xs.flatten(), ys.flatten(), ts.flatten()], dim=1)" + ] + }, + { + "cell_type": "markdown", + "id": "26d9c9ba-77fe-4c21-af35-12e1376b113e", + "metadata": {}, + "source": [ + "The TorchPhysics model cannot be directly evaluated at Pytorch Tensors. Tensors must first be transformed into TorchPhysics Points, which is easy to achieve. We only need to which space the \"tensors\" above belong to. In our case, it belongs to the space $X*T$. ATTENTION: Since the spatial coordinates has been fed into \"tensors\" first, it is important to define the space as $X*T$ and NOT $T*X$!\n", + "For more information on the Point class please have a look at (REFERENCE)." + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "67c99cdd-70db-4465-9ec0-8278b7381fa6", + "metadata": {}, + "outputs": [], + "source": [ + "points = tp.spaces.Points(tensors, space=X*T)" + ] + }, + { + "cell_type": "markdown", + "id": "ce94a359-75dd-41e7-85b3-2000b2065054", + "metadata": {}, + "source": [ + "Now the model can be evaluated at those points by its forward() method. In order to use e.g. \"plt.imshow()\", we need to transform the output into a numpy array." + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "id": "854b969a-96f2-4088-b045-d1ca5cf0db64", + "metadata": {}, + "outputs": [], + "source": [ + "output = model.forward(tp.spaces.Points(tensors, space=X*T))\n", + "output = output.as_tensor.reshape(100, 80, 1).detach().numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "id": "70d30023-ca42-460a-9906-2bcc736016ce", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(np.rot90(output[:, :]), 'gray', vmin=vmin, vmax=vmax)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc64a686-df6c-4967-b72f-ce2403d8551d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "raw", + "id": "6c9945aa-1730-420c-af9d-012984f1fe00", + "metadata": {}, + "source": [ + "plot_sampler = tp.samplers.AnimationSampler(plot_domain=Omega, animation_domain=I,\n", + " frame_number=20, n_points=600)\n", + "fig, animation = tp.utils.animate(model, lambda u : u, plot_sampler, ani_type='contour_surface', ani_speed=1)\n", + "\n", + "animation.save('animation_tut_1.gif')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e9d83ca6-61cf-4a75-bcfb-55b6b003b7b5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "26011d97-b8b9-404b-832e-d3554464df32", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 01047b5752836530c0689e067873c07dfa08739b Mon Sep 17 00:00:00 2001 From: kenaj123 <126678830+kenaj123@users.noreply.github.com> Date: Wed, 1 Mar 2023 13:55:19 +0100 Subject: [PATCH 07/30] Delete PINNs_Tutorial_Introduction.ipynb MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Janek Gödeke --- .../PINNs_Tutorial_Introduction.ipynb | 1016 ----------------- 1 file changed, 1016 deletions(-) delete mode 100644 examples/tutorial/PINNs_Tutorial_Introduction.ipynb diff --git a/examples/tutorial/PINNs_Tutorial_Introduction.ipynb b/examples/tutorial/PINNs_Tutorial_Introduction.ipynb deleted file mode 100644 index 7061741f..00000000 --- a/examples/tutorial/PINNs_Tutorial_Introduction.ipynb +++ /dev/null @@ -1,1016 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "1ef6d147-2dd4-4547-9fb6-79b3758d7350", - "metadata": {}, - "outputs": [], - "source": [ - "import torchphysics as tp\n", - "import numpy as np\n", - "import torch\n", - "from matplotlib import pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "id": "7cf51978-f0cb-4331-ba1c-9ee4ca6bf8f0", - "metadata": {}, - "source": [ - "# Physics Informed Neural Networks (PINNs) in TorchPhysics\n", - "In this tutorial we present a first basic example of solving a PDE with boundary constraints in TorchPhysics using a PINN approach.\n", - "You will also learn about the different components of this library and main steps for finding a neural network that approximates the solution of a PDE. \n", - "\n", - "We want to solve the time-dependent heat equation for a perfectly insulated room $\\Omega\\subset \\mathbb{R}^2$ in which a heater is turned on. \n", - "$$\n", - "\\begin{cases}\n", - "\\frac{\\partial}{\\partial t} u(x,t) &= \\Delta_x u(x,t) &&\\text{ on } \\Omega\\times I, \\\\\n", - "u(x, t) &= u_0 &&\\text{ on } \\Omega\\times \\{0\\},\\\\\n", - "u(x,t) &= h(t) &&\\text{ at } \\partial\\Omega_{heater}\\times I, \\\\\n", - "\\nabla_x u(x, t) \\cdot \\overset{\\rightarrow}{n}(x) &= 0 &&\\text{ at } (\\partial \\Omega \\setminus \\partial\\Omega_{heater}) \\times I.\n", - "\\end{cases}\n", - "$$\n", - "The initial room (and heater) temperature is $u_0 = 16$. The time domain is the interval $I = (0, 20)$, whereas the domain of the room is $\\Omega=(5,0) \\times (4,0)$. The heater is located at $\\partial\\Omega_{heater} = [1,3] \\times \\{4\\}$ and the temperature of the heater is described by the function $h$ defined below.\n", - "The normal vector at some $x\\in \\partial \\Omega$ is denoted by $\\overset{\\rightarrow}{n}(x)$." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "d6b5fdd2-67c1-4f7e-a185-9d515fb9f3f8", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "u_0 = 16 # initial temperature\n", - "u_heater_max = 40 # maximal temperature of the heater\n", - "t_heater_max = 5 # time at which the heater reaches its maximal temperature\n", - "\n", - "# heater temperature function\n", - "def h(t):\n", - " ht = u_0 + (u_heater_max - u_0) / t_heater_max * t\n", - " ht[t>t_heater_max] = u_heater_max\n", - " return ht\n", - "\n", - "# Visualize h(t)\n", - "t = np.linspace(0, 20, 200)\n", - "plt.plot(t, h(t))\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "8da6279e-83c2-41ed-a56b-453b21f05d11", - "metadata": {}, - "source": [ - "# Recall PINNs\n", - "The goal is to find a neural network $u_\\theta: \\overline{\\Omega\\times I} \\to \\mathbb{R}$, which approximately satisfies all four conditions of the PDE problem above, where $\\theta$ are the trainable parameters of the neural network.\n", - "Let us shortly recall the main idea behind PINNs.\n", - "\n", - "In our case, there is no data available (e.g. temperature measurements in $\\Omega$), which could be used for training the neural network. Hence, we can only exploit the four conditions listed above.\n", - "\n", - "The residuals are denoted by \n", - "$$\n", - "\\begin{align}\n", - "&\\text{1) Residual of pde condition: } &&R_1(u, x, t) := u(x, t) - \\Delta_x u(x,t) \\\\\n", - "&\\text{2) Residual of initial condition: } &&R_2(u, x) := u(x, 0) - u_0\\\\\n", - "&\\text{3) Residual of dirichlet boundary condition: } &&R_3(u, x, t) := u(x,t) - h(t)\\\\\n", - "&\\text{4) Residual of neumann boundary condition: } &&R_4(u, x, t) :=\\nabla_x u(x,t) \\cdot \\overset{\\rightarrow}{n}(x)\n", - "\\end{align}\n", - "$$\n", - "Continuing with the PINN approach, points are sampled in the domains corresponding to each condition. In our example points\n", - "$$\n", - "\\begin{align}\n", - "&\\text{1) } &&\\big(x^{(1)}_i, t_i^{(1)} \\big)_i &&&\\in \\Omega \\times I,\\\\\n", - "&\\text{2) } &&\\big(x^{(2)}_j, 0 \\big)_j &&&\\in \\Omega \\times \\{0\\},\\\\\n", - "&\\text{3) } &&\\big(x^{(3)}_k, t_k^{(3)} \\big)_k &&&\\in \\partial\\Omega_{heater} \\times I,\\\\\n", - "&\\text{4) } &&\\big(x^{(4)}_l, t_l^{(4)} \\big)_l &&&\\in (\\partial\\Omega \\setminus \\partial\\Omega_{heater}) \\times I.\n", - "\\end{align}\n", - "$$\n", - "Then, the network $u_\\theta$ is trained by solving the following minimization problem\n", - "$$\n", - "\\begin{align}\n", - "\\min_\\theta \\sum_{i} \\big\\vert R_1(u_\\theta, x^{(1)}_i, t_i^{(1)}) \\big \\vert^2\n", - "+ \\sum_j \\big\\vert R_2(u_\\theta, x^{(2)}_j) \\big \\vert^2\n", - "+ \\sum_k \\big\\vert R_3(u_\\theta, x^{(3)}_k, t_k^{(3)}) \\big \\vert^2\n", - "+ \\sum_l \\big\\vert R_4(u_\\theta, x^{(4)}_l, t_l^{(4)}) \\big \\vert^2,\n", - "\\end{align}\n", - "$$\n", - "that is, the residuals are minimized with respect to the $l_2$-norm.\n", - "It is to be noted here that if data was available, one could simply add a data loss term to the loss function above." - ] - }, - { - "cell_type": "markdown", - "id": "8f0db4a0-cace-4d21-845f-f34680880d7d", - "metadata": {}, - "source": [ - "# Translating the PDE Problem into the Language of TorchPhysics\n", - "Translating the PDE problem into the framework of TorchPhysics works in a convenient and intuitive way, as the notation is close to the mathematical formulation. The general procedure can be devided into five steps. Also when solving other problems with TorchPhysics, such as parameter identification or variational problems, the same steps can be applied, see also the further tutorials or examples (REFERENCE)." - ] - }, - { - "cell_type": "markdown", - "id": "e8fe0433-82b7-4093-8f6f-8adf7e46ff5b", - "metadata": {}, - "source": [ - "### Step 1: Specify spaces and domains\n", - "The spatial domain $\\Omega$ is a subset of the space $\\mathbb{R}^2$, the time domain $I$ is a subset of $\\mathbb{R}$, whereas the temperature $u(x,t)$ attains values in $\\mathbb{R}$. First, we need to let TorchPhysics know which spaces and domains we are dealing with and how variables/elements within these spaces are denoted by.\n", - "This is realized by generating objects of TorchPhysics' Space and Domain classes in \"tp.spaces\" and \"tp.domains\", respectively. \n", - "Some simple domains are already predefined, which will be sufficient for this tutorial. For creating complexer domains please have a look at the (REFERENCE DOMAIN-TUTORIAL)." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "6af0dba0-d481-4566-a8b7-244098eee713", - "metadata": {}, - "outputs": [], - "source": [ - "# Input and output spaces\n", - "X = tp.spaces.R2(variable_name='x')\n", - "T = tp.spaces.R1('t')\n", - "U = tp.spaces.R1('u')\n", - "\n", - "# Domains\n", - "Omega = tp.domains.Parallelogram(space=X, origin=[0,0], corner_1=[5,0], corner_2=[0,4])\n", - "I = tp.domains.Interval(space=T, lower_bound=0, upper_bound=20)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1efe92cb-daab-4d21-8a43-5008e3e9248a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# The domain can be visualized by creating a sampler object, see also step 2, and use the scatter plot function from tp.utils. \n", - "Omega_sampler = tp.samplers.RandomUniformSampler(Omega, n_points=1000)\n", - "plot = tp.utils.scatter(X, Omega_sampler)" - ] - }, - { - "cell_type": "markdown", - "id": "a1676bc3-8dab-4ce4-84ff-f8fc29e8b829", - "metadata": {}, - "source": [ - "### Step 2: Define point samplers for different subsets of $\\overline{\\Omega\\times I}$\n", - "As mentioned in the PINN recall, it will be necessary to sample points in different subsets of the full domain $\\overline{\\Omega\\times I}$. TorchPhysics provides this functionality by sampler classes in \"tp.samplers\". For simplicity, we consider only Random Uniform Samplers for the subdomains. However, there are many more possibilities to sample points in TorchPhysics, see also (REFERENCE SAMPLER-TUTORIAL).\n", - "\n", - "The most important inputs of a sampler constructor are the \"domain\" from which points will be sampled, as well as the \"number of points\" drawn every time the sampler is called. It is reasonable to create different sampler objects for the different conditions of the pde problem, simply because the subdomains differ.\n", - "\n", - "For instance, the pde condition 1) should hold for points in the domain $\\Omega \\times I$. We have already created $\\Omega$ and $I$ as TorchPhysics Domains in Step 1. Their cartesian product is simply obtained by the multiplication operator \"$*$\":" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "d428cf7f-89ee-4f3f-a1bf-822b82550a7e", - "metadata": {}, - "outputs": [], - "source": [ - "domain_pde_condition = Omega * I" - ] - }, - { - "cell_type": "markdown", - "id": "8db04580-edb8-45ac-8f48-091450647377", - "metadata": {}, - "source": [ - "Having the relevant domain on hand, we initialize as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "d020f7f4-c286-466f-928d-1f80ee64c53f", - "metadata": {}, - "outputs": [], - "source": [ - "sampler_pde_condition = tp.samplers.RandomUniformSampler(domain=domain_pde_condition, n_points=15000)" - ] - }, - { - "cell_type": "markdown", - "id": "ac69b667-1a77-4e8a-8a20-2e0b5a1de2a0", - "metadata": {}, - "source": [ - "There is an important alternative way of creating a sampler for a cartesian product of domains. Instead of defining the sampler on $\\Omega\\times I$, it is also possible to create samplers on $\\Omega$ and $I$ seperately, and multiply the samplers instead. This might be useful if different resolutions shall be considered, or when using other samplers in TorchPhysics such as a GridSampler, since a GridSampler cannot directly be created on a cartesian product in the way above." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "3a1ee851-1bd4-4ee2-83e4-7dca3f883c0f", - "metadata": {}, - "outputs": [], - "source": [ - "sampler_Omega = tp.samplers.GridSampler(domain=Omega, n_points=10000)\n", - "sampler_I = tp.samplers.RandomUniformSampler(domain=I, n_points=5000)\n", - "alternative_sampler_pde_condition = sampler_Omega * sampler_I " - ] - }, - { - "cell_type": "markdown", - "id": "c9f72b70-0e87-466f-a7c0-0e1f194745cc", - "metadata": {}, - "source": [ - "For more detailed information on the functionality of TorchPysics samplers, please have a look at (REFERENCE EXAMPLES & SAMPLER-TUTORIAL)\n", - "\n", - "Next, let us define samplers for the initial and boundary conditions. Regarding the initial condition the domain is $\\Omega \\times \\{0\\}$, so we need access to the left boundary of the time interval $I$. All tp.domains.Interval objects have the attribute \"left_boundary\", an instance of TorchPhysics BoundaryDomain class, a subclass of the Domain class." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "e780f5fa-5ebf-4731-8568-77116ea039f6", - "metadata": {}, - "outputs": [], - "source": [ - "domain_initial_condition = Omega * I.boundary_left\n", - "sampler_initial_condition = tp.samplers.RandomUniformSampler(domain_initial_condition, 5000)" - ] - }, - { - "cell_type": "markdown", - "id": "7750bf6b-30ec-4ca9-8f37-9699439d0d22", - "metadata": {}, - "source": [ - "Both the Dirichlet and Neumann boundary conditions should hold on subsets of the boundary $\\partial \\Omega \\times I$. It is easier to use a sampler for the whole boundary and determine later (in Step 3, the definition of the residual functions) whether a sampled point belongs to the domain $\\partial \\Omega_{heater}\\times I$ of the Dirichlet condition, or to the domain $(\\partial \\Omega \\setminus \\partial \\Omega_{heater}) \\times I$ of the Neumann condition." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "b627951a-a12b-4333-b965-35a56b8fc396", - "metadata": {}, - "outputs": [], - "source": [ - "domain_boundary_condition = Omega.boundary * I\n", - "sampler_boundary_condition = tp.samplers.RandomUniformSampler(domain_boundary_condition, 5000)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "c23a19e6-4167-4785-8323-984c319e2cb4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# TODO: Plot at two or three times\n", - "plot = tp.utils.scatter(X, sampler_boundary_condition)" - ] - }, - { - "cell_type": "markdown", - "id": "6b1b87f9-b6d6-44ec-8fb5-833ab466d89b", - "metadata": {}, - "source": [ - "### Step 3: Define residual functions\n", - "As mentioned in the PINNs Recall, we are looking for a neural network $u_\\theta$ for which all of the residual functions $R_1,...,R_4$ vanish.\n", - "\n", - "Let us have a look at $R_1$, the residual for the pde condition, the way it is defined in the PINNs Recall above. The inputs of $R_1$ are spatial and temporal coordinates $x\\in \\Omega$, $t\\in I$, but also the temperature $u_\\theta$, which is itself a function of $x$ and $t$. In TorchPhysics, the evaluation of the network $u_\\theta$ at $(x,t)$ is done before evaluating the residual functions. This means that from now on we consider $R_1$ as well as the other residuals to be functions, whose inputs are triples $(u, x, t)$, where $u:=u_\\theta(x,t)$.\n", - "\n", - "More precisely, $u$ will be a torch.tensor of shape (n_points, 1), $x$ of shape (n_points, 2) and $t$ of shape (n_points, 1), where n_points is the number of triples $(u,x,t)$ for which the residual should be computed.\n", - "\n", - "For the residual $R_1$ it is required to compute the laplacian of $u$ with respect to $x$, as well as the gradient with respect to $t$. These differential operators, among others - see (REFERENCE UTILS-TUTORIAL), are pre-implemented and can be found in \"tp.utils\". The intern computation is build upon torch's autograd functionality." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "c29f3f92-d613-470f-ab74-9369e071ea04", - "metadata": {}, - "outputs": [], - "source": [ - "def residual_pde_condition(u, x, t):\n", - " return tp.utils.laplacian(u, x) - tp.utils.grad(u, t)" - ] - }, - { - "cell_type": "markdown", - "id": "e444a2e5-6fc6-4124-894c-1ba987153241", - "metadata": {}, - "source": [ - "For the computation of the residual $R_2$ of the initial condition, the coordinates $x$ and $t$ are not required, since $u$ is already the evaluation of the network at these points. Therefore, we can conveniently omit them as input parameters." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "65954de9-4c80-4d2a-be6e-0cd16ab82596", - "metadata": {}, - "outputs": [], - "source": [ - "def residual_initial_condition(u):\n", - " return u - u_0" - ] - }, - { - "cell_type": "markdown", - "id": "97b9bfba-5cd3-400c-8c5a-4cd48b320c80", - "metadata": {}, - "source": [ - "In Step 2, we defined a boundary sampler for $\\partial \\Omega \\times I$, the domain for the boundary conditions. Hence, the sampler does not differ between the domain of the Dirichlet and Neumann boundary conditions. This is why we define a combined residual function $R_b$ for $R_3$ and $R_4$, which will output\n", - "$$\n", - "\\begin{align}\n", - "R_b(u, x, t) = \\begin{cases}\n", - "R_3(u, x, t) &\\text{ if } &&x \\in \\partial \\Omega_{heater},\\\\\n", - "R_4(u, x, t) &\\text{ if } &&x \\in \\partial \\Omega \\setminus \\partial \\Omega_{heater}.\n", - "\\end{cases}\n", - "\\end{align}\n", - "$$\n", - "Let us start with the defintion of the Dirichlet residual $R_3$:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "c97e8bfe-1580-4bb8-bb1b-d4c874ef6244", - "metadata": {}, - "outputs": [], - "source": [ - "def residual_dirichlet_condition(u, t):\n", - " return u - h(t)" - ] - }, - { - "cell_type": "markdown", - "id": "de441693-0870-43db-8d8d-38777a075432", - "metadata": {}, - "source": [ - "For the Neumann residual $R_4$ we need the normal derivative of $u$ at $x$. This differential operator is also contained in \"tp.utils\", whereas the normal vectors at points $x\\in \\partial \\Omega$ are available by the attribute \"normal\" of the \"boundary\" of the domain $\\Omega$." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "17d5e293-57bd-4739-9518-a014f6df2b79", - "metadata": {}, - "outputs": [], - "source": [ - "def residual_neumann_condition(u, x):\n", - " normal_vectors = Omega.boundary.normal(x)\n", - " normal_derivative = tp.utils.normal_derivative(u, normal_vectors, x)\n", - " return normal_derivative " - ] - }, - { - "cell_type": "markdown", - "id": "463e507e-d33b-4f8d-9149-c45356fdf236", - "metadata": {}, - "source": [ - "The combined boundary residual $R_b$ is then easily obtained as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "4864c6ed-6f2b-4f80-bd6f-cd8ff3d8a809", - "metadata": {}, - "outputs": [], - "source": [ - "def residual_boundary_condition(u, x, t):\n", - " # Create boolean tensor indicating which points x belong to the dirichlet condition (heater location)\n", - " heater_location = (x[:, 0] >= 1 ) & (x[:, 0] <= 3) & (x[:, 1] >= 3.99) \n", - " # First compute Neumann residual everywhere, also at the heater position\n", - " residual = residual_neumann_condition(u, x)\n", - " # Now change residual at the heater to the Dirichlet residual\n", - " residual_h = residual_dirichlet_condition(u, t)\n", - " residual[heater_location] = residual_h[heater_location]\n", - " return residual" - ] - }, - { - "cell_type": "markdown", - "id": "0cc89ada-310b-4a84-bcc0-77baa7afca2c", - "metadata": {}, - "source": [ - "### Step 4: Define Neural Network\n", - "At this point, let us define the model $u_\\theta:\\overline{\\Omega\\times I}\\to \\mathbb{R}$. This task is handled by the TorchPhysics Model class, which is contained in \"tp.models\". It inherits from the torch.nn.Module class from Pytorch, which means that building own models can be achieved in a very similar way, see (REFERENCE MODEL-TUTORIAL).\n", - "There are also a bunch of predefined neural networks or single layers available, e.g. fully connected networks (FCN) or normalization layers, which are subclasses of TorchPhysics' Model class. \n", - "In this tutorial we consider a very simple neural network, constructed in the following way:\n", - "\n", - "We start with a normalization layer, which maps points $(x,t)\\in \\overline{\\Omega\\times I}\\subset \\mathbb{R}^3$ into the cube $[-1, 1]^3$." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "bdef3d80-90e6-47aa-95ce-6d735fd03f36", - "metadata": {}, - "outputs": [], - "source": [ - "normalization_layer = tp.models.NormalizationLayer(Omega*I)" - ] - }, - { - "cell_type": "markdown", - "id": "75e0d506-13f0-4e39-882b-d752c89fe7fc", - "metadata": {}, - "source": [ - "Afterwards, the scaled points will be passed through a fully connected network. The constructor requires to include the input space $X\\times T$, output space $U$ and ouput dimensions of the hidden layers. Remember the definition of the TorchPyhsics spaces $X,T$ and $U$ from Step 1. Similar as for domains, the cartesian product of spaces is obtained by the multiplication operator \"$*$\". Here, we consider a fully connected network with four hidden layers, the latter consisting of $80, 50, 50$ and $50$ neurons, respectively." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "fa15606a-a2c7-40bf-9e41-920c8f6a1bc9", - "metadata": {}, - "outputs": [], - "source": [ - "fcn_layer = tp.models.FCN(input_space=X*T, output_space=U, hidden = (80,50,50,50))" - ] - }, - { - "cell_type": "markdown", - "id": "694d8666-170e-4c28-a87a-73aa329e2094", - "metadata": {}, - "source": [ - "Similar to Pytorch, the normalization layer and FCN can be concatenated by the class \"tp.models.Sequential\":" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "9b838d6f-1b90-4667-8ecb-9f54b4ec627e", - "metadata": {}, - "outputs": [], - "source": [ - "model = tp.models.Sequential(normalization_layer, fcn_layer)" - ] - }, - { - "cell_type": "markdown", - "id": "17e3f8ab-bd6c-4f4f-94a6-030930458c0c", - "metadata": {}, - "source": [ - "### Step 5: Create TorchPhysics Conditions\n", - "Let us sum up what we have done so far: For the pde, initial and combined boundary condition of the PDE problem, we constructed samplers and residuals on the corresponding domains.\n", - "Moreover, we have defined a neural network which will later be trained to fulfull each of these conditions.\n", - "\n", - "As a final step, we collect these constructions for each condition in an object of the TorchPhysics Condition class, contained in \"tp.conditions\". \n", - "Since we are interested in applying a PINN approach, we create objects of the subclass PINNCondition, which automatically contains the information that the residuals should be minimized in the squared $l_2$-norm, see again the PINN Recall. For other TorchPhysics Conditions one may need to specify which norm should be taken of the residuals, see (REFERENCE CONDITION-TUTORIAL) for further information." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "008c09a7-81f8-41b5-8c10-3892812740ad", - "metadata": {}, - "outputs": [], - "source": [ - "pde_condition = tp.conditions.PINNCondition(module =model, \n", - " sampler =sampler_pde_condition,\n", - " residual_fn=residual_pde_condition)\n", - "\n", - "initial_condition = tp.conditions.PINNCondition(module =model, \n", - " sampler =sampler_initial_condition,\n", - " residual_fn=residual_initial_condition)\n", - "\n", - "boundary_condition = tp.conditions.PINNCondition(module =model, \n", - " sampler =sampler_boundary_condition,\n", - " residual_fn=residual_boundary_condition)" - ] - }, - { - "cell_type": "markdown", - "id": "5cd77316-3c78-4bf1-b639-9ccb7070af2d", - "metadata": {}, - "source": [ - "It is to be noted that TorchPhysics' Condition class is a subclass of the torch.nn.Module class and its forward() method returns the current loss of the respective condition.\n", - "For example, calling forward() of the pde_condition at points $(x_i, t_i)_i$ in $\\Omega\\times I$ will return\n", - "$$\n", - "\\begin{align}\n", - "\\sum_i \\big \\vert R_1(u_\\theta, x_i, t_i) \\big \\vert^2,\n", - "\\end{align}\n", - "$$\n", - "where $R_1$ is the residual function for the pde condition defined in the PINN recall and $u_\\theta$ is the model defined in Step 4." - ] - }, - { - "cell_type": "markdown", - "id": "2e0fad4c-2cfd-4c10-8e2f-0a3702a2eeac", - "metadata": {}, - "source": [ - "The reason that also the model is required for initializing a Condition object is, that it could be desireable in some cases to train different networks for different conditions of the PDE problem. (TODO: EXAMPLE?)" - ] - }, - { - "cell_type": "markdown", - "id": "31d80c43-5879-401c-8212-0e4a5fd6514c", - "metadata": {}, - "source": [ - "# Training based on Pytorch Lightning \n", - "In order to train a model, TorchPhysics makes use of the Pytorch Lightning library, which hence must be imported. Further, we import \"os\" so that GPUs can be used for the calculations." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "bb76e892-bf53-4a01-adc5-74dddb770525", - "metadata": {}, - "outputs": [], - "source": [ - "import pytorch_lightning as pl\n", - "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\" # select GPUs to use" - ] - }, - { - "cell_type": "markdown", - "id": "1639cf38-835b-4571-b0c5-7ef0d130c2df", - "metadata": {}, - "source": [ - "For the training process, i.e. the minimization of the loss function introduced in the PINN recall, TorchPhysics provides the Solver class. It inherits from the pl.LightningModule class and is compatible with the TorchPhysics library. The constructor requires a list of TorchPhysics Conditions, whose parameters should be optimized during the training." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "ea27b608-e319-4fac-85c1-5984f2d043c6", - "metadata": {}, - "outputs": [], - "source": [ - "training_conditions = [pde_condition, initial_condition, boundary_condition]" - ] - }, - { - "cell_type": "markdown", - "id": "e024913e-e10e-4387-b390-165e77c8524b", - "metadata": {}, - "source": [ - "By default, the Solver uses the Adam Optimizer from Pytorch with learning rate $lr=0.001$ for optimizing the training_conditions. If a different optimizer or choice of its arguments shall be used, one can collect these information in an object of TorchPhysics' OptimizerSetting class. Here we choose the Adam Optimizer from Pytorch with a learning rate $lr=0.002$." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "b1848d26-ea33-400c-84be-2291429e8065", - "metadata": {}, - "outputs": [], - "source": [ - "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.0005)" - ] - }, - { - "cell_type": "markdown", - "id": "efcd0c8c-1ef2-45a0-bf00-de88201f3d03", - "metadata": {}, - "source": [ - "Finally, we are able to create the Solver object, a Pytorch Lightning Module." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "4ea2cb3f-087c-4e03-aeb0-40318f556062", - "metadata": {}, - "outputs": [], - "source": [ - "solver = tp.solver.Solver(train_conditions=training_conditions, optimizer_setting=optim)" - ] - }, - { - "cell_type": "markdown", - "id": "53dec402-5dd2-40f9-a405-5170d0cfcbd7", - "metadata": {}, - "source": [ - "Now, as usual, the training is done with a Pytorch Lightning Trainer object and its fit() method." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "9ea9431a-9ea4-4312-8869-af4c8c4733a4", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True, used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "HPU available: False, using: 0 HPUs\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 9.5 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "9.5 K Trainable params\n", - "0 Non-trainable params\n", - "9.5 K Total params\n", - "0.038 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Sanity Checking: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a050f77d9e2d482da29dd2227d5ab966", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Start the training\n", - "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", - " max_steps=1000, # number of training steps\n", - " logger=False,\n", - " benchmark=True,\n", - " checkpoint_callback=False)\n", - "\n", - "trainer.fit(solver) # start training" - ] - }, - { - "cell_type": "markdown", - "id": "c2fa291a-73b1-476b-8302-3aa63c34c61a", - "metadata": {}, - "source": [ - "You can also re-run the last three blocks with a smaller learning rate to further decrease the loss.\n", - "\n", - "Of course, the state dictionary of the model can be saved in the common way: torch.save(model.state_dict(), 'sd')" - ] - }, - { - "cell_type": "markdown", - "id": "bac7c186-2be3-4ce0-a252-527ae5083019", - "metadata": {}, - "source": [ - "# Visualization\n", - "Torchphysics provides built-in functionalities for visualizing the outcome of the neural network.\n", - "As a first step, for the 2D heat equation example one might be interested in creating a contour plot for the heat distribution inside of the room at some fixed time.\n", - "\n", - "For this purpose, we use the plot() function from \"tp.utils\", which is built on the Matplotlib library. The most important inputs are:\n", - "1) model: The neural network whose output shall be visualized.\n", - "2) point_function: Will be applied to the model's output before visualization. E.g. if the output was two-dimensional, the plot_function $u\\mapsto u[:, 0]$ could be used for showing only its first coordinate.\n", - "3) plot_sampler: A sampler creating points the neural network will be evaluated at for creating the plot.\n", - "4) plot_type: Specify what kind of plot should be created. \n", - "\n", - "Let us start with the sampler. The samplers we have seen so far (RandomUniformSampler, GridSampler) plot either on the interior or the boundary of their domain.\n", - "However, it is desirable to consider both the interior and the boundary points in the visualization. For this, one can use a PlotSampler, which is desined for harmonizing with plotting duties.\n", - "\n", - "We wish to visualize the heat distribution in $\\overline{\\Omega}$ at some fixed time $t'$. The latter can be added to the attribute \"data_for_other_variables\" of the PlotSampler." - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "00c3d1e0-aeda-4e15-9ca5-67bbb953bd73", - "metadata": {}, - "outputs": [], - "source": [ - "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=600, data_for_other_variables={'t':0.})" - ] - }, - { - "cell_type": "markdown", - "id": "5f9efe1d-cf26-4274-9ac0-1bba28e04827", - "metadata": {}, - "source": [ - "In our case, the model's output is a scalar and we do not want to modify it before plotting. Hence, plot_function should be the identity mapping. As we wish to use a colormap/contour plot to visualize the heat in $\\Omega$, we specify the plot_type as 'contour_surface'.\n", - "\n", - "Finally, we obtain the desired plot at time $t'=0$ by" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "3b514990-7c54-4896-b391-9275011df402", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/s_e8mv8u/anaconda3/envs/tp/lib/python3.9/site-packages/torchphysics/utils/plotting/plot_functions.py:416: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at /opt/conda/conda-bld/pytorch_1646756402876/work/torch/csrc/utils/tensor_new.cpp:210.)\n", - " embed_point = Points(torch.tensor([center]), domain.space)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "vmin = 15 # limits for the axes\n", - "vmax = 42\n", - "fig = tp.utils.plot(model =model, plot_function=lambda u : u, \n", - " point_sampler=plot_sampler, plot_type ='contour_surface',\n", - " vmin=vmin, vmax=vmin)" - ] - }, - { - "cell_type": "markdown", - "id": "54c7788a-d7a0-438c-821e-bef10f3f780f", - "metadata": {}, - "source": [ - "Let us visualize the solution of the PDE at further time points." - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "e9e54d6e-f7a2-4746-a05e-681e3dbee8b7", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=600, data_for_other_variables={'t':4.})\n", - "fig = tp.utils.plot(model, lambda u : u, \n", - " plot_sampler, plot_type='contour_surface',\n", - " vmin=vmin, vmax=vmax)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "10a7c785-90da-4b62-964f-af7d816ed1bd", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=600, data_for_other_variables={'t':8.})\n", - "fig = tp.utils.plot(model, lambda u : u, \n", - " plot_sampler, plot_type='contour_surface',\n", - " vmin=vmin, vmax=vmax)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "c3e6a8cf-6bd5-42d6-a3ac-16c4a64eb22b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=600, data_for_other_variables={'t':12.})\n", - "fig = tp.utils.plot(model, lambda u : u, plot_sampler, plot_type='contour_surface',\n", - " vmin=vmin, vmax=vmax)" - ] - }, - { - "cell_type": "markdown", - "id": "9d58e206-c27f-4ee6-8f4d-ddb1415c7221", - "metadata": {}, - "source": [ - "It is also possible to evaluate the model manually at torch Tensors. Say, we want to evaluate it on a spatial grid at some fixed time $t'= 6$." - ] - }, - { - "cell_type": "code", - "execution_count": 123, - "id": "9ccbb9b3-6f6a-4a29-8dc7-c2360b2df7c9", - "metadata": {}, - "outputs": [], - "source": [ - "x_coords = torch.linspace(0, 5, 100)\n", - "y_coords = torch.linspace(0, 4, 80)\n", - "t_coords = torch.linspace(6, 6 , 1)\n", - "#t_coords = torch.linspace(0, 20, 120)\n", - "xs, ys, ts = torch.meshgrid([x_coords, y_coords, t_coords])\n", - "tensors = torch.stack([xs.flatten(), ys.flatten(), ts.flatten()], dim=1)" - ] - }, - { - "cell_type": "markdown", - "id": "26d9c9ba-77fe-4c21-af35-12e1376b113e", - "metadata": {}, - "source": [ - "The TorchPhysics model cannot be directly evaluated at Pytorch Tensors. Tensors must first be transformed into TorchPhysics Points, which is easy to achieve. We only need to which space the \"tensors\" above belong to. In our case, it belongs to the space $X*T$. ATTENTION: Since the spatial coordinates has been fed into \"tensors\" first, it is important to define the space as $X*T$ and NOT $T*X$!\n", - "For more information on the Point class please have a look at (REFERENCE)." - ] - }, - { - "cell_type": "code", - "execution_count": 125, - "id": "67c99cdd-70db-4465-9ec0-8278b7381fa6", - "metadata": {}, - "outputs": [], - "source": [ - "points = tp.spaces.Points(tensors, space=X*T)" - ] - }, - { - "cell_type": "markdown", - "id": "ce94a359-75dd-41e7-85b3-2000b2065054", - "metadata": {}, - "source": [ - "Now the model can be evaluated at those points by its forward() method. In order to use e.g. \"plt.imshow()\", we need to transform the output into a numpy array." - ] - }, - { - "cell_type": "code", - "execution_count": 126, - "id": "854b969a-96f2-4088-b045-d1ca5cf0db64", - "metadata": {}, - "outputs": [], - "source": [ - "output = model.forward(tp.spaces.Points(tensors, space=X*T))\n", - "output = output.as_tensor.reshape(100, 80, 1).detach().numpy()" - ] - }, - { - "cell_type": "code", - "execution_count": 128, - "id": "70d30023-ca42-460a-9906-2bcc736016ce", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(np.rot90(output[:, :]), 'gray', vmin=vmin, vmax=vmax)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cc64a686-df6c-4967-b72f-ce2403d8551d", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "raw", - "id": "6c9945aa-1730-420c-af9d-012984f1fe00", - "metadata": {}, - "source": [ - "plot_sampler = tp.samplers.AnimationSampler(plot_domain=Omega, animation_domain=I,\n", - " frame_number=20, n_points=600)\n", - "fig, animation = tp.utils.animate(model, lambda u : u, plot_sampler, ani_type='contour_surface', ani_speed=1)\n", - "\n", - "animation.save('animation_tut_1.gif')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e9d83ca6-61cf-4a75-bcfb-55b6b003b7b5", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "26011d97-b8b9-404b-832e-d3554464df32", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.9.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 2bb0e14003cb632af66b080f01a1531d5df738ca Mon Sep 17 00:00:00 2001 From: kenaj123 <126678830+kenaj123@users.noreply.github.com> Date: Wed, 1 Mar 2023 14:15:04 +0100 Subject: [PATCH 08/30] PINNs Tutorial MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Janek Gödeke --- .../Introduction_Tutorial_PINNs.ipynb | 977 ++++++++++++++++++ 1 file changed, 977 insertions(+) create mode 100644 examples/tutorial/Introduction_Tutorial_PINNs.ipynb diff --git a/examples/tutorial/Introduction_Tutorial_PINNs.ipynb b/examples/tutorial/Introduction_Tutorial_PINNs.ipynb new file mode 100644 index 00000000..7071b468 --- /dev/null +++ b/examples/tutorial/Introduction_Tutorial_PINNs.ipynb @@ -0,0 +1,977 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "1ef6d147-2dd4-4547-9fb6-79b3758d7350", + "metadata": {}, + "outputs": [], + "source": [ + "import torchphysics as tp\n", + "import numpy as np\n", + "import torch\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "7cf51978-f0cb-4331-ba1c-9ee4ca6bf8f0", + "metadata": {}, + "source": [ + "# Physics Informed Neural Networks (PINNs) in TorchPhysics\n", + "In this tutorial we present a first basic example of solving a PDE with boundary constraints in TorchPhysics using a PINN approach.\n", + "You will also learn about the different components of this library and main steps for finding a neural network that approximates the solution of a PDE. \n", + "\n", + "We want to solve the time-dependent heat equation for a perfectly insulated room $\\Omega\\subset \\mathbb{R}^2$ in which a heater is turned on. \n", + "$$\n", + "\\begin{cases}\n", + "\\frac{\\partial}{\\partial t} u(x,t) &= \\Delta_x u(x,t) &&\\text{ on } \\Omega\\times I, \\\\\n", + "u(x, t) &= u_0 &&\\text{ on } \\Omega\\times \\{0\\},\\\\\n", + "u(x,t) &= h(t) &&\\text{ at } \\partial\\Omega_{heater}\\times I, \\\\\n", + "\\nabla_x u(x, t) \\cdot \\overset{\\rightarrow}{n}(x) &= 0 &&\\text{ at } (\\partial \\Omega \\setminus \\partial\\Omega_{heater}) \\times I.\n", + "\\end{cases}\n", + "$$\n", + "The initial room (and heater) temperature is $u_0 = 16$. The time domain is the interval $I = (0, 20)$, whereas the domain of the room is $\\Omega=(5,0) \\times (4,0)$. The heater is located at $\\partial\\Omega_{heater} = [1,3] \\times \\{4\\}$ and the temperature of the heater is described by the function $h$ defined below.\n", + "The normal vector at some $x\\in \\partial \\Omega$ is denoted by $\\overset{\\rightarrow}{n}(x)$." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d6b5fdd2-67c1-4f7e-a185-9d515fb9f3f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "u_0 = 16 # initial temperature\n", + "u_heater_max = 40 # maximal temperature of the heater\n", + "t_heater_max = 5 # time at which the heater reaches its maximal temperature\n", + "\n", + "# heater temperature function\n", + "def h(t):\n", + " ht = u_0 + (u_heater_max - u_0) / t_heater_max * t\n", + " ht[t>t_heater_max] = u_heater_max\n", + " return ht\n", + "\n", + "# Visualize h(t)\n", + "t = np.linspace(0, 20, 200)\n", + "plt.plot(t, h(t))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8da6279e-83c2-41ed-a56b-453b21f05d11", + "metadata": {}, + "source": [ + "# Recall PINNs\n", + "The goal is to find a neural network $u_\\theta: \\overline{\\Omega\\times I} \\to \\mathbb{R}$, which approximately satisfies all four conditions of the PDE problem above, where $\\theta$ are the trainable parameters of the neural network.\n", + "Let us shortly recall the main idea behind PINNs.\n", + "\n", + "In our case, there is no data available (e.g. temperature measurements in $\\Omega$), which could be used for training the neural network. Hence, we can only exploit the four conditions listed above.\n", + "\n", + "The residuals are denoted by \n", + "$$\n", + "\\begin{align}\n", + "&\\text{1) Residual of pde condition: } &&R_1(u, x, t) := u(x, t) - \\Delta_x u(x,t) \\\\\n", + "&\\text{2) Residual of initial condition: } &&R_2(u, x) := u(x, 0) - u_0\\\\\n", + "&\\text{3) Residual of dirichlet boundary condition: } &&R_3(u, x, t) := u(x,t) - h(t)\\\\\n", + "&\\text{4) Residual of neumann boundary condition: } &&R_4(u, x, t) :=\\nabla_x u(x,t) \\cdot \\overset{\\rightarrow}{n}(x)\n", + "\\end{align}\n", + "$$\n", + "Continuing with the PINN approach, points are sampled in the domains corresponding to each condition. In our example points\n", + "$$\n", + "\\begin{align}\n", + "&\\text{1) } &&\\big(x^{(1)}_i, t_i^{(1)} \\big)_i &&&\\in \\Omega \\times I,\\\\\n", + "&\\text{2) } &&\\big(x^{(2)}_j, 0 \\big)_j &&&\\in \\Omega \\times \\{0\\},\\\\\n", + "&\\text{3) } &&\\big(x^{(3)}_k, t_k^{(3)} \\big)_k &&&\\in \\partial\\Omega_{heater} \\times I,\\\\\n", + "&\\text{4) } &&\\big(x^{(4)}_l, t_l^{(4)} \\big)_l &&&\\in (\\partial\\Omega \\setminus \\partial\\Omega_{heater}) \\times I.\n", + "\\end{align}\n", + "$$\n", + "Then, the network $u_\\theta$ is trained by solving the following minimization problem\n", + "$$\n", + "\\begin{align}\n", + "\\min_\\theta \\sum_{i} \\big\\vert R_1(u_\\theta, x^{(1)}_i, t_i^{(1)}) \\big \\vert^2 + \\sum_j \\big\\vert R_2(u_\\theta, x^{(2)}_j) \\big \\vert^2 + \\sum_k \\big\\vert R_3(u_\\theta, x^{(3)}_k, t_k^{(3)}) \\big \\vert^2 + \\sum_l \\big\\vert R_4(u_\\theta, x^{(4)}_l, t_l^{(4)}) \\big \\vert^2,\n", + "\\end{align}\n", + "$$\n", + "that is, the residuals are minimized with respect to the $l_2$-norm.\n", + "It is to be noted here that if data was available, one could simply add a data loss term to the loss function above." + ] + }, + { + "cell_type": "markdown", + "id": "8f0db4a0-cace-4d21-845f-f34680880d7d", + "metadata": {}, + "source": [ + "# Translating the PDE Problem into the Language of TorchPhysics\n", + "Translating the PDE problem into the framework of TorchPhysics works in a convenient and intuitive way, as the notation is close to the mathematical formulation. The general procedure can be devided into five steps. Also when solving other problems with TorchPhysics, such as parameter identification or variational problems, the same steps can be applied, see also the further [tutorials](https://torchphysics.readthedocs.io/en/latest/tutorial/tutorial_start.html) or [examples](https://torchphysics.readthedocs.io/en/latest/examples.html)." + ] + }, + { + "cell_type": "markdown", + "id": "e8fe0433-82b7-4093-8f6f-8adf7e46ff5b", + "metadata": {}, + "source": [ + "### Step 1: Specify spaces and domains\n", + "The spatial domain $\\Omega$ is a subset of the space $\\mathbb{R}^2$, the time domain $I$ is a subset of $\\mathbb{R}$, whereas the temperature $u(x,t)$ attains values in $\\mathbb{R}$. First, we need to let TorchPhysics know which spaces and domains we are dealing with and how variables/elements within these spaces are denoted by.\n", + "This is realized by generating objects of TorchPhysics' Space and Domain classes in \"tp.spaces\" and \"tp.domains\", respectively. \n", + "Some simple domains are already predefined, which will be sufficient for this tutorial. For creating complexer domains please have a look at the [domain-tutorial](https://torchphysics.readthedocs.io/en/latest/tutorial/tutorial_domain_basics.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6af0dba0-d481-4566-a8b7-244098eee713", + "metadata": {}, + "outputs": [], + "source": [ + "# Input and output spaces\n", + "X = tp.spaces.R2(variable_name='x')\n", + "T = tp.spaces.R1('t')\n", + "U = tp.spaces.R1('u')\n", + "\n", + "# Domains\n", + "Omega = tp.domains.Parallelogram(space=X, origin=[0,0], corner_1=[5,0], corner_2=[0,4])\n", + "I = tp.domains.Interval(space=T, lower_bound=0, upper_bound=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1efe92cb-daab-4d21-8a43-5008e3e9248a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# The domain can be visualized by creating a sampler object, see also step 2, and use the scatter plot function from tp.utils. \n", + "Omega_sampler = tp.samplers.RandomUniformSampler(Omega, n_points=1000)\n", + "plot = tp.utils.scatter(X, Omega_sampler)" + ] + }, + { + "cell_type": "markdown", + "id": "a1676bc3-8dab-4ce4-84ff-f8fc29e8b829", + "metadata": {}, + "source": [ + "### Step 2: Define point samplers for different subsets of $\\overline{\\Omega\\times I}$\n", + "As mentioned in the PINN recall, it will be necessary to sample points in different subsets of the full domain $\\overline{\\Omega\\times I}$. TorchPhysics provides this functionality by sampler classes in \"tp.samplers\". For simplicity, we consider only Random Uniform Samplers for the subdomains. However, there are many more possibilities to sample points in TorchPhysics, see also [sampler-tutorial](https://torchphysics.readthedocs.io/en/latest/tutorial/sampler_tutorial.html).\n", + "\n", + "The most important inputs of a sampler constructor are the \"domain\" from which points will be sampled, as well as the \"number of points\" drawn every time the sampler is called. It is reasonable to create different sampler objects for the different conditions of the pde problem, simply because the subdomains differ.\n", + "\n", + "For instance, the pde condition 1) should hold for points in the domain $\\Omega \\times I$. We have already created $\\Omega$ and $I$ as TorchPhysics Domains in Step 1. Their cartesian product is simply obtained by the multiplication operator \"$*$\":" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d428cf7f-89ee-4f3f-a1bf-822b82550a7e", + "metadata": {}, + "outputs": [], + "source": [ + "domain_pde_condition = Omega * I" + ] + }, + { + "cell_type": "markdown", + "id": "8db04580-edb8-45ac-8f48-091450647377", + "metadata": {}, + "source": [ + "Having the relevant domain on hand, we initialize as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d020f7f4-c286-466f-928d-1f80ee64c53f", + "metadata": {}, + "outputs": [], + "source": [ + "sampler_pde_condition = tp.samplers.RandomUniformSampler(domain=domain_pde_condition, n_points=15000)" + ] + }, + { + "cell_type": "markdown", + "id": "ac69b667-1a77-4e8a-8a20-2e0b5a1de2a0", + "metadata": {}, + "source": [ + "There is an important alternative way of creating a sampler for a cartesian product of domains. Instead of defining the sampler on $\\Omega\\times I$, it is also possible to create samplers on $\\Omega$ and $I$ seperately, and multiply the samplers instead. This might be useful if different resolutions shall be considered, or when using other samplers in TorchPhysics such as a GridSampler, since a GridSampler cannot directly be created on a cartesian product in the way above." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3a1ee851-1bd4-4ee2-83e4-7dca3f883c0f", + "metadata": {}, + "outputs": [], + "source": [ + "sampler_Omega = tp.samplers.GridSampler(domain=Omega, n_points=10000)\n", + "sampler_I = tp.samplers.RandomUniformSampler(domain=I, n_points=5000)\n", + "alternative_sampler_pde_condition = sampler_Omega * sampler_I " + ] + }, + { + "cell_type": "markdown", + "id": "c9f72b70-0e87-466f-a7c0-0e1f194745cc", + "metadata": {}, + "source": [ + "For more detailed information on the functionality of TorchPysics samplers, please have a look at the [examples](https://torchphysics.readthedocs.io/en/latest/examples.html) or [sampler-tutorial](https://torchphysics.readthedocs.io/en/latest/tutorial/sampler_tutorial.html).\n", + "\n", + "Next, let us define samplers for the initial and boundary conditions. Regarding the initial condition the domain is $\\Omega \\times \\{0\\}$, so we need access to the left boundary of the time interval $I$. All tp.domains.Interval objects have the attribute \"left_boundary\", an instance of TorchPhysics BoundaryDomain class, a subclass of the Domain class." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e780f5fa-5ebf-4731-8568-77116ea039f6", + "metadata": {}, + "outputs": [], + "source": [ + "domain_initial_condition = Omega * I.boundary_left\n", + "sampler_initial_condition = tp.samplers.RandomUniformSampler(domain_initial_condition, 5000)" + ] + }, + { + "cell_type": "markdown", + "id": "7750bf6b-30ec-4ca9-8f37-9699439d0d22", + "metadata": {}, + "source": [ + "Both the Dirichlet and Neumann boundary conditions should hold on subsets of the boundary $\\partial \\Omega \\times I$. It is easier to use a sampler for the whole boundary and determine later (in Step 3, the definition of the residual functions) whether a sampled point belongs to the domain $\\partial \\Omega_{heater}\\times I$ of the Dirichlet condition, or to the domain $(\\partial \\Omega \\setminus \\partial \\Omega_{heater}) \\times I$ of the Neumann condition." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b627951a-a12b-4333-b965-35a56b8fc396", + "metadata": {}, + "outputs": [], + "source": [ + "domain_boundary_condition = Omega.boundary * I\n", + "sampler_boundary_condition = tp.samplers.RandomUniformSampler(domain_boundary_condition, 5000)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c23a19e6-4167-4785-8323-984c319e2cb4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# TODO: Plot at two or three times\n", + "plot = tp.utils.scatter(X, sampler_boundary_condition)" + ] + }, + { + "cell_type": "markdown", + "id": "6b1b87f9-b6d6-44ec-8fb5-833ab466d89b", + "metadata": {}, + "source": [ + "### Step 3: Define residual functions\n", + "As mentioned in the PINNs Recall, we are looking for a neural network $u_\\theta$ for which all of the residual functions $R_1,...,R_4$ vanish.\n", + "\n", + "Let us have a look at $R_1$, the residual for the pde condition, the way it is defined in the PINNs Recall above. The inputs of $R_1$ are spatial and temporal coordinates $x\\in \\Omega$, $t\\in I$, but also the temperature $u_\\theta$, which is itself a function of $x$ and $t$. In TorchPhysics, the evaluation of the network $u_\\theta$ at $(x,t)$ is done before evaluating the residual functions. This means that from now on we consider $R_1$ as well as the other residuals to be functions, whose inputs are triples $(u, x, t)$, where $u:=u_\\theta(x,t)$.\n", + "\n", + "More precisely, $u$ will be a torch.tensor of shape (n_points, 1), $x$ of shape (n_points, 2) and $t$ of shape (n_points, 1), where n_points is the number of triples $(u,x,t)$ for which the residual should be computed.\n", + "\n", + "For the residual $R_1$ it is required to compute the laplacian of $u$ with respect to $x$, as well as the gradient with respect to $t$. These differential operators, among others - see [utils-tutorial](https://torchphysics.readthedocs.io/en/latest/tutorial/differentialoperators.html), are pre-implemented and can be found in \"tp.utils\". The intern computation is build upon torch's autograd functionality." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c29f3f92-d613-470f-ab74-9369e071ea04", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_pde_condition(u, x, t):\n", + " return tp.utils.laplacian(u, x) - tp.utils.grad(u, t)" + ] + }, + { + "cell_type": "markdown", + "id": "e444a2e5-6fc6-4124-894c-1ba987153241", + "metadata": {}, + "source": [ + "For the computation of the residual $R_2$ of the initial condition, the coordinates $x$ and $t$ are not required, since $u$ is already the evaluation of the network at these points. Therefore, we can conveniently omit them as input parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "65954de9-4c80-4d2a-be6e-0cd16ab82596", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_initial_condition(u):\n", + " return u - u_0" + ] + }, + { + "cell_type": "markdown", + "id": "97b9bfba-5cd3-400c-8c5a-4cd48b320c80", + "metadata": {}, + "source": [ + "In Step 2, we defined a boundary sampler for $\\partial \\Omega \\times I$, the domain for the boundary conditions. Hence, the sampler does not differ between the domain of the Dirichlet and Neumann boundary conditions. This is why we define a combined residual function $R_b$ for $R_3$ and $R_4$, which will output\n", + "$$\n", + "\\begin{align}\n", + "R_b(u, x, t) = \\begin{cases}\n", + "R_3(u, x, t) &\\text{ if } &&x \\in \\partial \\Omega_{heater},\\\\\n", + "R_4(u, x, t) &\\text{ if } &&x \\in \\partial \\Omega \\setminus \\partial \\Omega_{heater}.\n", + "\\end{cases}\n", + "\\end{align}\n", + "$$\n", + "Let us start with the defintion of the Dirichlet residual $R_3$:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c97e8bfe-1580-4bb8-bb1b-d4c874ef6244", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_dirichlet_condition(u, t):\n", + " return u - h(t)" + ] + }, + { + "cell_type": "markdown", + "id": "de441693-0870-43db-8d8d-38777a075432", + "metadata": {}, + "source": [ + "For the Neumann residual $R_4$ we need the normal derivative of $u$ at $x$. This differential operator is also contained in \"tp.utils\", whereas the normal vectors at points $x\\in \\partial \\Omega$ are available by the attribute \"normal\" of the \"boundary\" of the domain $\\Omega$." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "17d5e293-57bd-4739-9518-a014f6df2b79", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_neumann_condition(u, x):\n", + " normal_vectors = Omega.boundary.normal(x)\n", + " normal_derivative = tp.utils.normal_derivative(u, normal_vectors, x)\n", + " return normal_derivative " + ] + }, + { + "cell_type": "markdown", + "id": "463e507e-d33b-4f8d-9149-c45356fdf236", + "metadata": {}, + "source": [ + "The combined boundary residual $R_b$ is then easily obtained as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "4864c6ed-6f2b-4f80-bd6f-cd8ff3d8a809", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_boundary_condition(u, x, t):\n", + " # Create boolean tensor indicating which points x belong to the dirichlet condition (heater location)\n", + " heater_location = (x[:, 0] >= 1 ) & (x[:, 0] <= 3) & (x[:, 1] >= 3.99) \n", + " # First compute Neumann residual everywhere, also at the heater position\n", + " residual = residual_neumann_condition(u, x)\n", + " # Now change residual at the heater to the Dirichlet residual\n", + " residual_h = residual_dirichlet_condition(u, t)\n", + " residual[heater_location] = residual_h[heater_location]\n", + " return residual" + ] + }, + { + "cell_type": "markdown", + "id": "0cc89ada-310b-4a84-bcc0-77baa7afca2c", + "metadata": {}, + "source": [ + "### Step 4: Define Neural Network\n", + "At this point, let us define the model $u_\\theta:\\overline{\\Omega\\times I}\\to \\mathbb{R}$. This task is handled by the TorchPhysics Model class, which is contained in \"tp.models\". It inherits from the torch.nn.Module class from Pytorch, which means that building own models can be achieved in a very similar way, see [model-tutorial](https://torchphysics.readthedocs.io/en/latest/tutorial/model_creation.html).\n", + "There are also a bunch of predefined neural networks or single layers available, e.g. fully connected networks (FCN) or normalization layers, which are subclasses of TorchPhysics' Model class. \n", + "In this tutorial we consider a very simple neural network, constructed in the following way:\n", + "\n", + "We start with a normalization layer, which maps points $(x,t)\\in \\overline{\\Omega\\times I}\\subset \\mathbb{R}^3$ into the cube $[-1, 1]^3$." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "bdef3d80-90e6-47aa-95ce-6d735fd03f36", + "metadata": {}, + "outputs": [], + "source": [ + "normalization_layer = tp.models.NormalizationLayer(Omega*I)" + ] + }, + { + "cell_type": "markdown", + "id": "75e0d506-13f0-4e39-882b-d752c89fe7fc", + "metadata": {}, + "source": [ + "Afterwards, the scaled points will be passed through a fully connected network. The constructor requires to include the input space $X\\times T$, output space $U$ and ouput dimensions of the hidden layers. Remember the definition of the TorchPyhsics spaces $X,T$ and $U$ from Step 1. Similar as for domains, the cartesian product of spaces is obtained by the multiplication operator \"$*$\". Here, we consider a fully connected network with four hidden layers, the latter consisting of $80, 50, 50$ and $50$ neurons, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "fa15606a-a2c7-40bf-9e41-920c8f6a1bc9", + "metadata": {}, + "outputs": [], + "source": [ + "fcn_layer = tp.models.FCN(input_space=X*T, output_space=U, hidden = (80,50,50,50))" + ] + }, + { + "cell_type": "markdown", + "id": "694d8666-170e-4c28-a87a-73aa329e2094", + "metadata": {}, + "source": [ + "Similar to Pytorch, the normalization layer and FCN can be concatenated by the class \"tp.models.Sequential\":" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9b838d6f-1b90-4667-8ecb-9f54b4ec627e", + "metadata": {}, + "outputs": [], + "source": [ + "model = tp.models.Sequential(normalization_layer, fcn_layer)" + ] + }, + { + "cell_type": "markdown", + "id": "17e3f8ab-bd6c-4f4f-94a6-030930458c0c", + "metadata": {}, + "source": [ + "### Step 5: Create TorchPhysics Conditions\n", + "Let us sum up what we have done so far: For the pde, initial and combined boundary condition of the PDE problem, we constructed samplers and residuals on the corresponding domains.\n", + "Moreover, we have defined a neural network which will later be trained to fulfull each of these conditions.\n", + "\n", + "As a final step, we collect these constructions for each condition in an object of the TorchPhysics Condition class, contained in \"tp.conditions\". \n", + "Since we are interested in applying a PINN approach, we create objects of the subclass PINNCondition, which automatically contains the information that the residuals should be minimized in the squared $l_2$-norm, see again the PINN Recall. For other TorchPhysics Conditions one may need to specify which norm should be taken of the residuals, see [condition-tutorial](https://torchphysics.readthedocs.io/en/latest/tutorial/condition_tutorial.html) for further information." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "008c09a7-81f8-41b5-8c10-3892812740ad", + "metadata": {}, + "outputs": [], + "source": [ + "pde_condition = tp.conditions.PINNCondition(module =model, \n", + " sampler =sampler_pde_condition,\n", + " residual_fn=residual_pde_condition)\n", + "\n", + "initial_condition = tp.conditions.PINNCondition(module =model, \n", + " sampler =sampler_initial_condition,\n", + " residual_fn=residual_initial_condition)\n", + "\n", + "boundary_condition = tp.conditions.PINNCondition(module =model, \n", + " sampler =sampler_boundary_condition,\n", + " residual_fn=residual_boundary_condition)" + ] + }, + { + "cell_type": "markdown", + "id": "5cd77316-3c78-4bf1-b639-9ccb7070af2d", + "metadata": {}, + "source": [ + "It is to be noted that TorchPhysics' Condition class is a subclass of the torch.nn.Module class and its forward() method returns the current loss of the respective condition.\n", + "For example, calling forward() of the pde_condition at points $(x_i, t_i)_i$ in $\\Omega\\times I$ will return\n", + "$$\n", + "\\begin{align}\n", + "\\sum_i \\big \\vert R_1(u_\\theta, x_i, t_i) \\big \\vert^2,\n", + "\\end{align}\n", + "$$\n", + "where $R_1$ is the residual function for the pde condition defined in the PINN recall and $u_\\theta$ is the model defined in Step 4." + ] + }, + { + "cell_type": "markdown", + "id": "2e0fad4c-2cfd-4c10-8e2f-0a3702a2eeac", + "metadata": {}, + "source": [ + "The reason that also the model is required for initializing a Condition object is, that it could be desireable in some [cases](https://github.com/TomF98/torchphysics/blob/main/examples/pinn/interface-jump.ipynb) to train different networks for different conditions of the PDE problem. (TODO: EXAMPLE?)" + ] + }, + { + "cell_type": "markdown", + "id": "31d80c43-5879-401c-8212-0e4a5fd6514c", + "metadata": {}, + "source": [ + "# Training based on Pytorch Lightning \n", + "In order to train a model, TorchPhysics makes use of the Pytorch Lightning library, which hence must be imported. Further, we import \"os\" so that GPUs can be used for the calculations." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "bb76e892-bf53-4a01-adc5-74dddb770525", + "metadata": {}, + "outputs": [], + "source": [ + "import pytorch_lightning as pl\n", + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\" # select GPUs to use" + ] + }, + { + "cell_type": "markdown", + "id": "1639cf38-835b-4571-b0c5-7ef0d130c2df", + "metadata": {}, + "source": [ + "For the training process, i.e. the minimization of the loss function introduced in the PINN recall, TorchPhysics provides the Solver class. It inherits from the pl.LightningModule class and is compatible with the TorchPhysics library. The constructor requires a list of TorchPhysics Conditions, whose parameters should be optimized during the training." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "ea27b608-e319-4fac-85c1-5984f2d043c6", + "metadata": {}, + "outputs": [], + "source": [ + "training_conditions = [pde_condition, initial_condition, boundary_condition]" + ] + }, + { + "cell_type": "markdown", + "id": "e024913e-e10e-4387-b390-165e77c8524b", + "metadata": {}, + "source": [ + "By default, the Solver uses the Adam Optimizer from Pytorch with learning rate $lr=0.001$ for optimizing the training_conditions. If a different optimizer or choice of its arguments shall be used, one can collect these information in an object of TorchPhysics' OptimizerSetting class. Here we choose the Adam Optimizer from Pytorch with a learning rate $lr=0.002$." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "b1848d26-ea33-400c-84be-2291429e8065", + "metadata": {}, + "outputs": [], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.0005)" + ] + }, + { + "cell_type": "markdown", + "id": "efcd0c8c-1ef2-45a0-bf00-de88201f3d03", + "metadata": {}, + "source": [ + "Finally, we are able to create the Solver object, a Pytorch Lightning Module." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "4ea2cb3f-087c-4e03-aeb0-40318f556062", + "metadata": {}, + "outputs": [], + "source": [ + "solver = tp.solver.Solver(train_conditions=training_conditions, optimizer_setting=optim)" + ] + }, + { + "cell_type": "markdown", + "id": "53dec402-5dd2-40f9-a405-5170d0cfcbd7", + "metadata": {}, + "source": [ + "Now, as usual, the training is done with a Pytorch Lightning Trainer object and its fit() method." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "9ea9431a-9ea4-4312-8869-af4c8c4733a4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 9.5 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "9.5 K Trainable params\n", + "0 Non-trainable params\n", + "9.5 K Total params\n", + "0.038 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a050f77d9e2d482da29dd2227d5ab966", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Start the training\n", + "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", + " max_steps=1000, # number of training steps\n", + " logger=False,\n", + " benchmark=True,\n", + " checkpoint_callback=False)\n", + "\n", + "trainer.fit(solver) # start training" + ] + }, + { + "cell_type": "markdown", + "id": "c2fa291a-73b1-476b-8302-3aa63c34c61a", + "metadata": {}, + "source": [ + "You can also re-run the last three blocks with a smaller learning rate to further decrease the loss.\n", + "\n", + "Of course, the state dictionary of the model can be saved in the common way: torch.save(model.state_dict(), 'sd')" + ] + }, + { + "cell_type": "markdown", + "id": "bac7c186-2be3-4ce0-a252-527ae5083019", + "metadata": {}, + "source": [ + "# Visualization\n", + "Torchphysics provides built-in functionalities for visualizing the outcome of the neural network.\n", + "As a first step, for the 2D heat equation example one might be interested in creating a contour plot for the heat distribution inside of the room at some fixed time.\n", + "\n", + "For this purpose, we use the plot() function from \"tp.utils\", which is built on the Matplotlib library. The most important inputs are:\n", + "1) model: The neural network whose output shall be visualized.\n", + "2) point_function: Will be applied to the model's output before visualization. E.g. if the output was two-dimensional, the plot_function $u\\mapsto u[:, 0]$ could be used for showing only its first coordinate.\n", + "3) plot_sampler: A sampler creating points the neural network will be evaluated at for creating the plot.\n", + "4) plot_type: Specify what kind of plot should be created. \n", + "\n", + "Let us start with the sampler. The samplers we have seen so far (RandomUniformSampler, GridSampler) plot either on the interior or the boundary of their domain.\n", + "However, it is desirable to consider both the interior and the boundary points in the visualization. For this, one can use a PlotSampler, which is desined for harmonizing with plotting duties.\n", + "\n", + "We wish to visualize the heat distribution in $\\overline{\\Omega}$ at some fixed time $t'$. The latter can be added to the attribute \"data_for_other_variables\" of the PlotSampler." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "00c3d1e0-aeda-4e15-9ca5-67bbb953bd73", + "metadata": {}, + "outputs": [], + "source": [ + "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=600, data_for_other_variables={'t':0.})" + ] + }, + { + "cell_type": "markdown", + "id": "5f9efe1d-cf26-4274-9ac0-1bba28e04827", + "metadata": {}, + "source": [ + "In our case, the model's output is a scalar and we do not want to modify it before plotting. Hence, plot_function should be the identity mapping. As we wish to use a colormap/contour plot to visualize the heat in $\\Omega$, we specify the plot_type as 'contour_surface'.\n", + "\n", + "Finally, we obtain the desired plot at time $t'=0$ by" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "3b514990-7c54-4896-b391-9275011df402", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/s_e8mv8u/anaconda3/envs/tp/lib/python3.9/site-packages/torchphysics/utils/plotting/plot_functions.py:416: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at /opt/conda/conda-bld/pytorch_1646756402876/work/torch/csrc/utils/tensor_new.cpp:210.)\n", + " embed_point = Points(torch.tensor([center]), domain.space)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "vmin = 15 # limits for the axes\n", + "vmax = 42\n", + "fig = tp.utils.plot(model =model, plot_function=lambda u : u, \n", + " point_sampler=plot_sampler, plot_type ='contour_surface',\n", + " vmin=vmin, vmax=vmin)" + ] + }, + { + "cell_type": "markdown", + "id": "54c7788a-d7a0-438c-821e-bef10f3f780f", + "metadata": {}, + "source": [ + "Let us visualize the solution of the PDE at further time points." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "e9e54d6e-f7a2-4746-a05e-681e3dbee8b7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbIAAAEJCAYAAADxfqKqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABGE0lEQVR4nO29f7QlZXnn+3nOafo0TfNLMS30YQJ3Qky4OMF4AgjxriPgDLQsmRh/NGuQJYm3R6NBubYuNWM6Y+6sm8SDM3qNMD3oMIiKiK1DhFFYkX3VNYHY/FAaIQkJBrpBoXMv0Fv61+nz3D+q6pzatd+qemvvql1Vez+ftc46e1e971tP7R/vdz/v+7zPK6qKYRiGYbSVqboNMAzDMIxhMCEzDMMwWo0JmWEYhtFqTMgMwzCMVmNCZhiGYbQaEzLDMAyj1ayq2wDDMIxJQUTWAN8FZgj631tVdauIfAV4RVjsOOA5VT3TUf9q4J2AAg8BV6rq/hGY3mhaKWQnnHCCnnLKKd7lf/7zn3PUUUdVZ9AIsHuon7bbD5N5D/fdd98eVX3ZMNe86DjRPYue1/s531bVi1JOHwDOV9WuiBwBfF9E/oeqvi0qICLXAM8nK4rIBuAq4HRV3ScitwCbgBsK3cwY0kohO+WUU9ixY4d3+U6nw/z8fHUGjQC7h/ppu/0wmfcgIv847DX3LMKOV3pe7x5OSDunQQaKbvj0iPBvOSuFiAjwVuD8lCZWAUeKyCFgLfCUn1Xjjc2RGYZhjBARmRaRB4FngLtU9d7Y6dcCP1PVv0vWU9XdwALwBPA08Lyq3jkCkxuPCZlhGEYeQjCr5fMHJ4jIjtjf5nhTqno4nP+aBc4SkTNipy8Dvuw0QeR44FLgVOAk4CgRubysW2wzrRxaNAzDaDB7VHUur5CqPiciHeAiYKeIrALeBLw6pcqFwOOq+iyAiGwHzgVuKsXqFmMemWEYRh5TwBrPvwxE5GUiclz4+EgCcXo0PH0h8Kiq7kqp/gRwjoisDefSLgAeGfiexggTMsMwjNFxInC3iPwI+AHBHNk3w3ObSAwrishJInIHQDiXditwP0Ho/RSwbVSGN5mRDC2KyDSwA9itqpckzgnwKWAj8CLwDlW9fxR2GYZhjBJV/RHwqpRz73Ace4qgb4yebwW2VmVfWxnVHNn7CFzgYxznLgZOC//OBq4N/xuGYTSDKNjDaCSVDy2KyCzwBuD6lCKXAjdqwD3AcSJyYtV2GYZhGOPBKDyy/wR8CDg65fwG4MnY813hsafjhcIQ1s0A69evp9PpeBvQ7XbpdDo8xnPedXqujSaeLy0/noqdk57HS8vnxPF/5XFvueh59FjC9rR7PLd3rl2umyw3hYIqUwosESyxjP8nccy3HIn/yTLx88SOxQnPd18yS2fbNb1lkj+lJPHcdX4q8T86njwWPZ5OPJb+c0sCSzKFhq/qEsIS07HHU2j3JXy987nlc0vIcnnteWekp53448i46Hjw8sjy/6Xlx1PLx5eWwmO68mL0bOy+NNXzOocX6CV8PrvY5ZrbO71lXeXj+Gwin1V/CF59fP+x6Ps8UqYwj6zBVCpkInIJ8Iyq3ici82nFHMf6vjqquo1wYnNubk6LrOyPMgH8Gdu968SZ4WDP89UcyDh3MDx+YPl5/DHANIeXy8TLr+YgqznATPg/an+awxzqvI3j5j/Xc3ylbHCN1YcPMr24yMyBJVYdAPYTJMSJ/yd8vBj+d5WLbi9ZnsS5ZLn4efqPdX57gfntW3rLJ6O8ZlIex8vOhI+j86sSx2Zi5aPjR8XKHdt77ufHTHF41SoOTgev6F7WRa8oXY7mADMcZppDnU28MH8XB8NXfW94DuAw04l3L/q//O5wMGwnqnOQ1eHLE5yLHgfnZji4FJ7fH5bfv3r5pVg8NL38eOlAeMP7Y1/nZPa9fcG/hT0dtpww3/8+ZWXry8vkty/n/DD8DFaSNwWMQ3YSo1yq9sjOA94oIhsJuo5jROQmVY0v4tsFnBx7PktFaVcOxnrG1c4e180BVvcJls+5lTIzzHCAg6xeFq4Vm3qPpdmoTC13fD62L8443twZ3EKTPB+JVPR8TezYKlZELToebzcuTFEHGN1S9Ks2KVBpguU6HxezpICReB6VPSZRNkPEXOISiM9qJPzNFQlVRFLEhuVg3wuSzrKIVUWdIhYiX+kXs5Ej5IbWG/VRqZCp6keAjwCEHtmWhIgB3Aa8V0RuJgjyeF5Vn6Zios6iiKDF6+bVyxKvw0wve2Xx8oE9/aI203Mso6OchtXAAQKvDPD78kXiEr+lNJGKjkWCFhe7iKSAEZaZJvCG0myIkyVmcVGK2x8XtLh3Fi9/7MrjxRn6RCwuYHHBOsgMRyChd5UtWPG28vApMzRJsSn+ka+dRoiZ0VhqyewhIu8CUNXrgDsIwksfIwi/v7KKa17I7c7jvoLm43kF7fULV1B/ZnmIMXksXifeQcavp4k2Un+1x8QsmrhwvslJ7yuPqHxc2KLH0QUWY8cj4iKYJWTx60QkDY+LVPQ8KWjJ4UXXsGMoYi8etdopYiv/Z5a9Mej1ioNbC85nkRxWzKI0URvVph4j8MbimJgZaYxMyFS1A3TCx9fFjivwnlHZkcYwHpqvyAXXCUQrzSuLi128Y5uOlQnsPNhXJl54RcwAloq90ckhxeTzZBli5VaMD4iLXFoIc5pgRaxxnHPNg6UJWFQ+nBtbnIEDM1OZIpYcYjzA6tTXMDnU6MMwQ5Dx+bFSSBO+Bu5yJV+Bu9fXcGEL9mg0lmsxgc+woW+5pMdV1CtLzpFF4hfvNF02HGBmWcyC5zneWYRryNAlYq5hx8ik5FxZXPimCIIuXGQNJcafr8l4nhxGhF6Ri4nYvpm1qSIW3MaKBxUdX4v0BHMkGUTQgnoT3kMeTjwvWaeN8WcihOxveZ4ybtU36CNteDFiEK8s6pfjdXJ/1YcdQq53FnX0abqcNk+W9MiistAvcJE9RYYWo+slzyXFLC5g0XmHmEUidnjVKqeIRRxk9fKQYpbIREEeScoI+Gg8wwwrJoUr7XyTBM2CPRrNRAhZUXy9skEY1CtTZFksoxDuqE4WMxzg4PTqYt6Zy+MCt5cG7mFF15d+GvfwTJ43ljW06ClgsCJie6eP7gvsAJaHFOMBHvGhxiXnSpGV4I7eY/1eXlS2EvaX/FWuYlgxT8DSyjdJ0IxGYkI2BEUErz/MPt1rcwV1zNAbxRgXs3i5VKZh9eGDoTeS45255sXigR3R0COsCFv0OGoD+jvDKdI9MpfwzTger0o8dw01pgjYwelojVZvRGFcrJIBHkniZfrFq1j4/UgiFpP4LG6ugqIillbXRM1wYEKWQppIFR1edHlgceLzXslyURsHmVn2BlxiBiyXi845hS021Di9uMiBmSm85s4iXJ5aPJgja1iR8FJFhxZXOc5lzZOFj+PDiEBfYAf0e1xxEXN5Uy6yvLEixG0CMhdDR1S+hiyNosOKw4hYlW0VwYI9Go0JWQY+HleyjEvo0oI+XHNlaWWUqeW2i4pZ8DjWESYCQWYOLPUuoM6KVkyWiUiK2yL9JIcg47g+ifGyWeIVK5PmhbnWiWWJWJzofPAe+HtjcY8rHno/0ojFPNGpOjKxLuExJgoTshxcYjbMmrIiEYzJebA0kSrsmYEzEOTADMsLqb0+GMk5tGR4fpJDKQ1nzYklz6cIWlzAoH+hM/TOWwF9IhYnKXIHWY0iPeXy5saia2RResRiGcKU1UYRb2ycREyw3rLBTMhbI84IwXinlDwXJ0/MsryyvCHGpFeWJmbqGFpMZv5wiVmSuHeWDAQJ2kiI2gxB3sa0ABBX1GKaEyuUE7UYO54mYMG9uIcSo8dJEXOtJfMJs8/L5LHSfrzO6r7HA6em8g30GGVGj3ESsRIRkTXAd1mJtb1VVbeKyB8B/zvwbFj0o6p6h6P+1cA7CWY7HwKuVNUGrvgbLRMiZAFZmRWic2mClrdguoiYpT1fqdtfLt5OmpjF15hliVmSA9MrIusStb55NNdQoytEP0nWPENe5GKsjEu8gD4BCx73DyUCXiIWsTK0KD0i5hK6PG/MZ1gxbX5sJMOKZXhj4yhi5e1HdgA4X1W7InIE8H0R+R/huf+oqgupJohsAK4CTlfVfSJyC8Gu0jeUYlmLmSgh88HluaWRHGIsMwdjstxSLGGtr5jBiqCt5oBflFysr4xKv7gqCg5ZGXpc9tTi5A0tPk2+Rxa1kyApXuAWMOiNSnR5YVHZeHRiWqh8XPA0Fn7fL3TuAA+XN7ZSr0XRA5MsYiUSZjLqhk+PCP+KxJKuAo4UkUPAWipKsN42TMgcZIlZXnBH/LzPImlX4AfQN8zoKts/tLia5DCji0j8coXXIWoHYlEc0ejWsrgFjfcLXETOotJFh8lx4YJ08YJsAVs5HzxOBna4vDWX99Tr7aWH27vWjsW9xLTykTeWReqwYpEBpiasE5tQRGQauA/4JeDPVfVeEbmYIHn6FcAO4AOq+v/F66nqbhFZAJ4g+Glxp6reOWLzG4kJWQpleWaDDjEm58yiTRjTxCyJj6Dl3UvcnuXhx+nVrD7cK8iRx7bcxkxC3CKm/MQKVgQrTpp4RXYHz93CFNVLDiW6yibFKopSjHtkyfmu5H5ikD2U7SofJxpWHJikB+UzP5Ymbj7e2LiL2BRFMnucICI7Ys+3hfspAqCqh4EzReQ44OsicgZwLfDHBN7ZHwPXAL8Tb1REjgcuBU4FngO+KiKXq+pNA9zRWGFClkHavNkwkYwr5YuJWXBdd9nkMGM0jBhFNCavl5dCK9f2aUfgSkLgXnR8spamhBeP8pgjmnZ7QtA7pNebVipbwADnUGL02OVlxUXMNS+WFuBR1BvLwrV+rHGMu4gVZ4+qzuUVUtXnRKQDXBSfGxOR/wJ801HlQuBxVX02LLcdOBcwIavbgFGwFCZ7jchaoOzC5Z0ViWRM9XIyxAxYHmqc5nAsajFbzFwkQ/TLwCWGToGLsYQ4RWq5vkdwhCuQwjWEGG/P1wtLPk56VEupc2TDeWNpi6Dj5AZ6VDWsmOeNTYqIlRTsISIvAw6FInYkgTj9qYicGNuH8beAnY7qTwDniMhagnfmAoJhyIlnIoQsSfb8kbsjdnlnrkjGssQsXs7lVaWJWVZQR9xjrCrnX5a3Fy0oTquXJMvbcXljWQKWrOsjYmlemo998bI+c2MucrN5pIXdlzmsOCri1x/v5LwnAv8tnCebAm5R1W+KyBdE5EyCocWfAP8WQEROAq5X1Y3hXNqtwP0EKQceALY5rjFxVCpkaWsmEmXmgf8OPB4e2q6qH6/SriyizqeooJUtZpENK5k9pMe+POLDi8nOMjnkOCqi8HUXvp28yyNziUxyGNFV11fEVuyfipV1tx3V77ctvTwM6Y1lkfwYO6YuU6nSG8sSTlcWmTFBVX8EvMpx/O0p5Z8i2Hg4er4V2OoqO8lU7ZE510yo6j2Jct9T1UsqtqUQPoJWhpgBqXNk8WPxrBJZC6fTvLO0LB+DBoVkkRYNuRRm8HeVT5JXrneurH8o0Df4I3qeJWJJwUva4x7uTA+3TxtS7CnrWDvmFa3oGyYfxyUqVYjYoF5f3d4ilLmOzKiASoWshDUTtZMlaC4xA1JEq1fMgjbToxmDdtKHGn3FLLLHJWjJ47Aikj5khe+7hGiJafZytHfb/cf6xQv6hxDj9fPmz4qI2IpX3B+leJB+MS0a4DF0pGJfg4nnRRdAp1FUxJogRMZYU/kcmWvNhKPYa0TkhwSL+7ao6sNl2qBMOedu4h1jXhRfmqDlDTUOk8oqfiwZ7OESs0FxCVryvqPHRQNl4gRDi/mddfrwY794BccHE7D4c19PLCu1VFYqqsZ6Yy6y2plUESsWfm+MGAmcphFcKFwzAfy+qu6MHT8GWAqHHzcCn1LV0xz1NwObAdavX//qm2++2fvaz3afZ886f80Wj4mEKadjqallJHEufo20clGZKZS13RleXHcgcV5T/vu3XcTO4DmZ57NY6r6UqXX/lFsumovqP+4uE1/fFUUWRuejc2nHXf/Tyh7dXcXz6w6jTPW1S8Z10mzosW8pPKexc/EbXoq9Jj3HUx4nP57huVntskvWucu42klSpLuoqGt5xUyXdevWeZd/3eted59POHwWc6eI7viYX1l5J0NfzyjGyKIW42smiIWWquoLscd3iMhnReQEVd2TqL+NMEJnbm5O5+fnva99bed2Pjd/XGGb87w0l3cS98ySw25Jbyd+Pn4uft3oGmd3NvDA/E/6jkdlo+vGbXK14zoX2eFaB5d3D76LxgEOdi7jiPmvZJZJC1vvC45weD3x465gjbSoxqzoxLgn9q866/iL+UPLz9M8sbwAj6xw+4G9Mej1pFKGFRf2d9iyZj547trwuixvrEJP7O7/pUOR738p2H5kjabqqEXnmolEmZcDP1NVFZGzCD4y+T/bR0De0KNrqK13b7H+OTOIz425583y5sji13aF6OeRnIfLzpTv057f4mole30VpM8npQlX8tygApb2PC4+0Z5w8WsOKmLOe8xb/JyV5T5LxMrAV8TGZSjRaBVVe2RpaybeBaCq1wFvBt4tIosEX8dNOqrxzgLEO/44rrmzohGNQbvZKa3iod+RHWkLqKE3aMMVQFImPsmSAaZiQpDWThour2vleX8QSFZUo4+Axa8ZXS8YBtSBRazHZs9w+9RdoIvMjSXFpWgqKhMxo+FUHbWYtmbiutjjzwCfqdSOlLBvF3neRZagJcUMGNg7y1pvFj+eJlZ5ghaVyzqXFAzvDPopzOQEe/iKXH+2j/w1Zcl6RUVsUE/MdQ9ZAR6pVL3n2DCBIpMgYDkJr416mcjMHlnEO9MsUXOmaErxziBb0FzeWXKoMbkgOs3L8hG0rPrJcxFZQ5C+AneExw+KtGv4iFfynDsU3k/A4rZEx6JgjSLDuFnCltxvDEbgjSn9c2PDzItNgogZjceELINkp5sUtrKGG8vwziI78gQN/L20lftOD+8vsoFnsAwiu2zWMoKkXXnryuJlsry2LG+q99hiqifmqu/MQjLIkKLvVi0+68aKYCK2ggV7NBoTsgKkrbXyFbRhvLPkxprx9qNr+Aha0g4fTyzN8yi6fi0rRVUc33yMyXIuAYuXG8QL6x1KPOys7yqfJWI991RWlGIS38XPw86LDUueGNpwnuHBRAiZ70LciPxdnt1bthSZP0vLCOLjnbmiKYsMOUbn0ry0iDShcgmpD8ldCNIo4pXliVfacX8vbOUacfuzRMx5TzERcw0pRnglBYbBEgPntRHhI2KDeGOjqlMFlqKq0UyEkBXFFeSQJM07C+r3C1qedxZd1x2O39/JuvI1xq/Ta3/2HFhS1CK7XG0Nk0UkyrDiQ5rgJe30nTsr4oXFj/UOJR7KbSN+3BXc4Z0UOCliw27T4uvNVSFiTREjY2wxIfMg3km59iCL8BlyHHS4MZpfysrXuGLj4KIWlXGt9yqShzG5vi5Ks1XEi0tbczZI4Ef8nI8XFr/+Sq7FqcJCmCZiuUOKcfJEKP5Sl5VPMQ0TMaOBmJAVxLUHWUSROTSfcP24aK3kWuwVVZeQpnlpwwR2pImbCx/B823LZYs7s7zPsGIxLyzeVtDOiz11crOL5IhYnIHnxfKGFMuaF5t0AROst2wwE/HWpG0fkkX+erLhBS0vutFn7Vn2+XTRKhLYUWQ4MUvw4lvRxMlrO0+4XGUGETBwh9bnzYcNKmKRN1bavJjPwue0PIplidi4CVjJpO3RKCJ/DFxK8A49A7wj3IssWf9q4J0ECykeAq5U1Yl/1SdCyAYhL/Q+wmfY0SVoRYcbl1hMbbeIlxaUKeaJ5XlXcSHOEqXsjTWLheXne2VuoYqfcwlYsu34UKLLK86LThx4OBGy14uVGWpvIpZPecEezj0agU+o6scAROQq4A+Bd/WYILIBuAo4XVX3icgtwCbghlIsazEmZJ74CFual+YStGHmz6JruAXL7aX1lsmfT0uuUYuTtswgD585siIRi67yeQEYrnO+Xlg8+jXtOkWGE/vw3Z5l0H3G9kHfy1uGiI2zgJVM2h6N8eTpwFGk7x2wCjhSRA4Bawm2vpp4JkLIfBbiRvjkDIS8qMUqBO3wUMOO8TK95fpFLW5DnCxx82HJcx1Z2vUjssQrOJ897Bfh44UVadMnxH7oPcaGEbEkJmK1kLZHo4j8B+AK4Hngdcl6qrpbRBaAJwje0TtV9c6RGd5gJkLIiuASvCxxy45aLFfQYLAcjq57cXmYWdk74vZkkbXxZpA93n98Jts7Sxev5PmiApZWPz7X2pe4eNJEbNIErNjGmieIyI7Y823hNlQAqOph4Mxoj0YROUNVd6rqHwB/ICIfAd4LbI03KiLHE8yjnQo8B3xVRC5X1ZsGu6nxwYTMA591ZZAuamUI2hKHeiIdfQUtaY+vsPXWSReUQYcZ4/hl++gv48xfmBPEsVIuPzikqBcGbhFLrhNrtIj5ULaIJdtrfzaPPT4ba6bt0Qh8CbidhJARbIP1uKo+CyAi24FzAROyug1oI1kBHhGu7B9p9bIELSg7+Dxa8hoRecLmqpO0MWlnHnkpqgZNKOwz/7VSdvDoxuQQdZHIxIhSRMyFr4jlbZCUJ1LDiNgww5V1i1tJwR5pezSKyGmq+ndhsTcCjzqqPwGcIyJrCd7dC4AdjnITx0QImSLOPHc+rJ7yC8OHooul0+ewXGIR7Ue2UtYtaOAWtbRrJe3LynDvqlcE32UQefOZPt5Z2vDhSvn8CMeiXhiki1hfdOIwIuYTZp+2ViyLLKEZhYBV3UYzSNuj8Wsi8gqC8Pt/JIxYFJGTgOtVdaOq3isitwL3A4vAA8A251UmjIkQsmFIdlpZwjaIqPkGZQRl06MNXfNo0J8CK4nP0GJa3TRcXupBZgoF3USkCZ+rnSLel6vtvLB6SPfCoAUidpggRi6vzaLny67XRIrNkaWSsUfjb6eUfwrYGHu+lf4hx4mnUiFLW/yXKCPApwjerBcJFgLeX6Vdw+ArbEUXTOcNCWpiEymfdWHgzqCRJW55Q4sr7fsJug/DeGlFxSt5Pd8gkYNLq3veg6zQeq+gDii2JYurfBlZO6oQsXESMKMVVO2RORf/qeo9sTIXA6eFf2cD14b/S2NpSZzJWl3MrCmWRjwubC5RG8ZLS9bJ89SywufTPDbI99rybPElb6duHwF0CXPR9WWua2WJ2yBeGBQUsbgAtVHETLyMGqlUyNIW/yWKXQrcGJa9R0SOE5ETVfXpKm1LI0/wsoSuDFFLm0tLemR5ASLBNQYTtojpRA9Y1NNKssSidxtZuRh99ysLypYjYBD8IFo+5+uFQbaIjWI40UVZIjYpAmbbuDSayufI0hb/xdgAPBl7vis8VouQ5REXujJErawAEXd5d+RjUK//W5lcA5aX2DcpdEXxTRwMfl7XStn8YJAiAjawFwbDiVgVIfaa0kZW+2WUNYwKqVzI0hb/xYqIq1rygIhsBjYDrF+/nk6n423Dhp/v4+P3PFjA6sGYmsqObZac2GdJzegKv9A9xFWd3d5t5l0r73pxpjza8uElXXhrJ97D9ve2S86PA0R7gfVGb764/CjpsbqOJdtORoL2lV/qfX7Sz/fx7//qRyvlky/LUqy9vnM5z/PKu8pE5ZK6rbiDOhRmp7ssHNtxnAzbOtp9Kte2EdLtdgt9/0uhpGAPoxpGFrWYsfhvF3By7Pksjvxh4cr4bQBzc3M6Pz/vfe1P/uV3+MiZuesTM1m9JjsMP4nPXFtaoIgrQOQDnZ9wzfwpQdspgRZ56bXyMvoHbRS7zyJc0ely4/w67/KDrDnLWyTtKpPngUHghf1fD+zgI6+aG84Lg8Gz2Ce1uognFraxcGyHLc/Pp57PpQFe2N2/3qHI998Yf6qOWnQu/ksUuw14r4jcTBDk8Xxd82NZJOdE8oTNZwgy6kCTgpaXSaRokIirnqt+0IZ/Fo+y8M+/6JfdI638oAIWJzdzfdZeYlDOVixlzofVIWC+bZkHZHhStUeWtvjvXQCqeh1wB0Ho/WMEY0VXVmxTKbiymaeJW7KDTAqbz3xafA2WXyRj9sJmV/0eGx2iNWiy4Ij4DstZlJXhI618kTmwiMVD0z1DiUN7YdAOERtWwMpeSF2TuKnAogV7NJaqoxbTFv9dF3uswHuqtAP6J+V9WHVEsWCGeAeY5bFleWs+69SKpqFKq9tzHU+BSyNr2DK+Fq5ou0U8rrx6gwpYnFwBg+GHEtOOFRlKTGvD51yRMmXWq7tto7VMRGaPvkl5T9LEz0fgfIci84Ygo87XFcwA/uvU4hQROFe7LoZJXZV3fZ9rpNV3pSYbWMCWeoNDRuaFpbU1iBe2lHM+r36ZdVqETsGBman8gkDt0TATyEQIWdkMInA+wuYrastt5Mytgf9cGfjtgj0M8Y0p8xh0eBH8xAuy578icufBYLC5MFe9qkVsP/lRiUUFacwFzGgHJmQlkuwIfYUtT9RS2yg4DLlcLsXDyhMPn6jHPAb13IoKF/iJFxQQMGX4YI60enXPh5mAZaIiHF7l211WF/lruJkMIVuacndMAzI145fGylfYfObW4mm28qIg4/iKG+QPIQ47fJi+RmwFH48tayeDtB8AQwnYIB4YNMMLK+P8oGUNY0RMhpCVTJoo5gmcj7AVHYKM8BU33+z9WfjMmbnaHiT7PQwmXOAWLxhCwGCweTBXvbRjaW3W7YWZgBkNxoSsRJKdYRFhy/PWVKc4uH+1d4g/+M2zxcnbe225jYqSzvnuGTdy8YKgI0/O4Zc5jOhqL6JOETMBA8L53WnfEQkbWhw1kyVkaZ1UFmsWB75cEWEbZBgS/MP8I3zzQw5DXBDjbQ6ywWneXGGacEWUImBJyvbC0gQM3CI2jID5RC36tFOEQdsawwXRaVtbichbgD8CfhU4S1WdOz+LyNXAOwlmbB8CrlTVif+5MRlClpykL4JvPQ/BG0bY0kjryIt4bhFFt7BJtWkAQfTdZmcQ4YoYePhwuQGa64WVJU5ldYlltJNso0ZhC9ZA+o5EdLNOOre2Ikjb9ybgP6dVFJENwFXA6aq6T0RuATYBN3gaNrZMhpCNAleHmCNuRYRN1W8oMqJI5pEIXzEZlCL7wkG+aEG+4A/tfcFwHlja8aICVrT9Iud9y1RRt4nXqZC0ra1U9RGAYJ/hTFYBR4rIIWAtjry0k4gJWZUUFDdXp5smbmWsZUtSNDFyWfgIVsRAwhVRxPtKE5o2CZhPmTYI2JjhsbWVE1XdLSILwBMEn6Q7VfXO6ixtD5MhZL7zAoNQdLgj2Zn6em3hEoKikZERg2QjKZsoYMUXn+HV3GUVZXhfEAhYMkNMUYFpWjCHZfDwZskzT2jICSISn+PaFu7eAXhtbeVERI4n2Ij4VOA54Ksicrmq3uRr2LgyGUJWJVlfbB+RK8Frg+Kh/y6K5pYsg6I5MAcWLijH+8pqpywBG+Qavud9y5RRZ3LZo6q5+0ZlbG2VxoXA46r6LICIbAfOBUzI6jZgrBk0e/cAgSlZHfygC7jLJjnPl4fXIva81yqrAy4qYGme/SgEbJhz8TJF8o6aeC0zSMJrF55bW6XxBHCOiKwl+HRdADijGyeNyRayrLDnNI4c8pqDipsr8tJzaUAZIlclhbOuVCFeUJ4HlnWdNgwjmoBVSdrWVr8F/N/Ay4DbReRBVf1XInIScL2qblTVe0XkVuB+YBF4gHCz4UlnMoTMFTY9KD7tFBW7sj23AmvfykzdlX+xAVKF+XineR1v3ntmAjZ4eR98v3vD/kiskCIJrzPbSd/a6uvA1x3HnyLYrzF6vhXYOrQhY8ZkCNmoSfviFvmiJjuUIjtD+HT+Qyz0roQiw6k+ne2g4pXVvmacK1PA8s43WcCG+cGYrNtgYTOaRaVCJiInAzcCLyfoirep6qcSZeaB/w48Hh7arqofr9Ku2hhW4NI6m0EWio4qy0n8OoMuTPftZAcZNsy7xqDDlG0QsDLEq6yRDt+2TdwMB1V7ZIvAB1T1fhE5GrhPRO5S1R8nyn1PVS+p2JaAMqeEyhqVq0rgIsrKiDBodhTv9guU9elABxWvvHODCNgw1/M571umSLk0qhSvhl57qaRgD6MaKu2ZVPVp4Onw8V4ReQTYACSFrFqUcgUsokibg4he/EubnOcbZpgyi6rSAO1nuPV8vh3YMOKVdX4fsJr0fLBtEbBBNy+uU7wMI4eRzZGJyCkEk5yuVeyvEZEfEqRb2aKqDzvqbwY2A6xfv55Op+N97dnDXRZe8C8/UvK36AJgdrHLwp5OfkHf3dhrYPZQl4XdnexCRTtan3DyvDaz2ojqroZZ6bKwuuOud0RGu64fMVG7aTs2+7wOvqH0sbZm13RZ+JVO4XpNotvtFvr+l8GgWxAZo2EkQiYi64CvAe9X1RcSp+8HfjFMorkR+AZwWrKNcGX8NoC5uTmdn5/3vv413+yw5Rj/8o0i/O4s7Omw5YT58tsf4ZzDwu4OW14yP3gDvh5wUS/G9WPC4YEsrO6w5eB8tveVd/2ahxAXfqXDlkfn0+u0wPO6+w0dinz/jfGnciELMzx/Dfiiqm5Pno8Lm6reISKfFZETVHVP6caMen1MGcN0UeftGh4t4wfiKDuuIr/wiw4FlyEAea+FUu8uzVXOgbVAwOokCL+3ObKmUnXUogCfAx5R1U+mlHk58DNVVRE5i2Bw7J9KNaTKXItZ+FxzGLHL6+zbMBIy6NxlWZ16XgceFy7X8GGbBWyU4nWAdnwejVZStUd2HvB24CEReTA89lHgnwGo6nXAm4F3i8giwVdrU7jVwWQwbK7GLAYViWE6nKxrDhN0U3ZYeREBG+QaZQhUmwTM5331fe9N8IyCVB21+H1ywhlU9TPAZ6q0oxTKXMM1yDVdXmVV164za1WVC3mHFa+sBdERTRewMgI4qv58VDGEPiTFNtY0Rs3kZfYoe4ixaHtlio/vtasU26IM+/qX7X34JPyPrpnVj437EGKdP27qTwdqNJzJEDKfX9Kjog7xacq9D+INVNFpFxGvppQpUi5iGAEz8ehBEQ5T7e4QxuBMhpC1kWSnlSbGTfK2hmEUkXbDznv5limzLRMvw8jFhCyLQTuFUeaDG0QARil+cfuG9YzLFi4oJkxpi5cHaauMMnEG/ayaeBljwOQJ2ShCjuvY56wITRlqTGPQ98h3g+uyh/LqGj4072tklLWxplENkyFkS6TnyGsKeZ2SK89fmzOBl/GDwle4oB7xqqIcDOd9VZV31PAibUcQEfk14DpgHfAT4N84siAhIlcD7yR4Jx8CrlTVpv80rZzJELJxpSzvclhB9LUjK+luHkVEK6JsEfFdWN+04I2qhWuYz2FLfowtlZdr0bkjCHA9QZ7Z/0dEfgf4IPCxeEUR2QBcBZyuqvtE5BZgE3BDGYYBHHnkkT/dv3//+rLaGwVr1qz5mQmZD4N0ohFtCHRqUnqiYV7rshdNFy3bJAGrSrzK/qxM2J5jGTuCvAL4bljsLuDbJIQsZBVwpIgcAtYSJFovjf37969vWz4KEVk/uUI2TIc5yuu0QQgHoazXv27xKlK2bQJW1w+cQbcrqpCCc2QniMiO2PNtYdLzHhI7guwE3kiwyfBbgJP7bFDdLSILwBMEr9KdqnpnkfsYVyZDyLKSvTadyO5h7mEUYuhj27DvwyAzAXWLV9GyUK+ANck7h357GiJsOexR1bmsAskdQcLhxE+LyB8Ct+EYhBeR44FLgVOB54CvisjlqnpT2TfQNiZDyCadton4MFPXVaa4Klq+6gCOcRWvLNpkawquHUFU9VHgX4bnfxl4g6PqhcDjqvpsWG47cC5gQla3Aa2jSOc0LouVq6DMOKtRiZfP1EEbxGsMxGDUBNu4DB/skbYjiIj8gqo+IyJTwL8jiGBM8gRwjoisJXgXLwB2OMpNHA3eT3iE7C/wV1W7eX+aca4pFLmHMq9RtF7Ra5TZNgRdUFExOcBwIhZds6G7Pk8Q0Y4g54vIg+HfRuAyEflb4FGCAI7/CiAiJ4nIHQCqei9wK8FmxA8R9N99c29l89xzz/HZz3621DZvvfVWRIQdO9w6fN999/HKV76SX/qlX+Kqq64iLwAl1yMTkWOAl6nq3yeO/wtV/VEB2+unSZ1+mYzjfQ17T00aYoR6QufN8yqNIPx++AXROTuCfMpR/ilgY+z5VmDr0IYUIBKy3/u93yulvb179/LpT3+as88+O7XMu9/9brZt28Y555zDxo0b+da3vsXFF1+cWj7TIxORtxL8QviaiDwsIr8RO31DMfNrpElJg40VqvR8i9bzIVpHVnT4cFDvaxAR28dg1zSMFD784Q/z93//95x55pl88IMfHLq9j33sY3zoQx9izRr33MvTTz/NCy+8wGte8xpEhCuuuIJvfOMbmW3meWQfBV6tqk+Huzd/QUQ+Gk5QZu4zNtGkdXSTMmeWdv9HZ5wro/0q6g1Sp465r1EJV5nh/ba9Vyv4kz/5E3bu3MmDDz7oPP/a176WvXv39h1fWFjgwgsv7Dn2wAMP8OSTT3LJJZewsLDgbG/37t3Mzs4uP5+dnWX37t2ZNuYJ2XS4gA9V/WsReR3wTRGZxWPqOy0dS6KMELjUG4EXgXeo6v15bVdOFR7cMG2WJQJtY9RDjIPWGTfxGkUaK9c1GiputrFmOt/73ve8yi0tLXH11Vdzww03ZJZzzYcFMpFOnpDtFZF/Hs2PhZ7ZPPAN4H/NqQsp6VhU9cexMhcDp4V/ZwPXhv+rZxKFoamU9V6MMnQfRi9gbRevPOI2mG60Al+PbO/evezcuZP5+XkAfvrTn/LGN76R2267jbm5lWV3s7Oz7Nq1a/n5rl27OOmkkzJtyBOyd5MYQgzTqlwEvDWnblY6lriQXQrcqIEM3yMix4nIiZEnWAq+OfKMaqnifajDYxsH76sJopVHg0QtCL+fzOz3Rx99tFOoInw9smOPPZY9e/YsP5+fn2dhYaFHxABOPPFEjj76aO655x7OPvtsbrzxRn7/938/s+1MIVPVH6YcPwR8MXouIn+lqq/JaiuRjiXOBuDJ2PNd4bEeIRORzcBmgPXr19PpdLIu18Psqi4LL/Mv30QaeQ8FQ7lnV3dZ2NAZ7prDpoEbNPx8CWbXdFn45U6xesPYW3aovMLsui4L53VKbniECHS73ULff2M4XvrSl3LeeedxxhlncPHFF/OJT3yikuuceeaZy/Nw1157Le94xzvYt28fF198cWbEIpS3IDozjCGZjiV52lGl7+sf5irbBjA3N6eRe+rDNV/tsOVZ//JejNjDW9jQYcvu+dFetGQK3UMThhoTXtDCr3XY8sN5v7qDejwVe14L53fY8p35ki8yWu7+nQ5Fvv9lsMTURM+RfelLXyq9zeSPkXgwydzcHDt37vRuqywhS/3d6UrHkmAXvQkyZyk5o3MhbAhytDRtqLHt673aMGRoGCVTaYqqtHQsCW4D3isiNxMEeTxf6vxYGiZY1ZN8jctez1dGW3XtsmziZRil4SVkInJ6ItIQEZlX1U70NKVqlI7lIRF5MDz2UeCfAajqdcAdBKH3jxGE319ZwH4/LNhjMJr2mtUtXGDiNcEcHts9ldqPr0d2i4h8AfgzgvmwPwPmgCjA4+2uSjnpWKIyCrzH0472UZYYTFJ2kjLvswzxiERj0MCNsgSsLvFaLKENS09uVIjvx+ts4E+B/0mwNPeLBN4WAKrqPyvXdiZFTEZBVa9lmeJVpw0wWvEqQ7B8226ZsE1y+H0b8P04HSL4ah5J4JE9rqrjm0fbxKockq9jVUO8TRGNptjhQ5WiNej1WyZu48iaNWt+JiLr67ajCGvWrPmZ70fnBwRbcP8G8FLgP4vIm1X1zZVZNwpMsPxo0uvUtIXBbRMvpX4RSyOyywStNvbt2/fyum0YBN+PzO+qarRxzE+BS0XEOS/WaJrUIVfFON1j00Qroi1BG00VrDzidjdE1CZ9HVnT8fqYxEQsfuwL5ZtTEXUHSpRx7XGOvKwqf2DZIrFEM+bfXLRVtPIYMy8tLZG6iHwFeEVY7DjgOVU901H/auCdBL3aQ8CVqjquPYM3Y/LxqImJ//h4EnX+ZQlBFmWKRNOHDcdVvFzUfK8lBnukJVJ/W1RARK4Bnk9WFJENwFXA6aq6T0RuATbRpr0hK8KELA8Tq3Tq3ryxCoEw8TIqJC+RephE4q3A+SlNrAKOFJFDwFrqzILUIEzIIiZVsOoWI1+qEoY2zHeZeNVOwf3IThCR+HTMtjBXbA8pidRfC/xMVf+uzwbV3SKyADxB8Mm9U1Xv9DVqnJlMIWuzaLVFeAah6si9pgaPJDHhajt7VHUuq0BGIvXLgC+n1DmeYNurU4HngK+KyOWqelMpVreYyRCypgVKDNKhjmJ+aVSMapFvFa/XJARqDPpdydwDw4hIS6QuIquANwGvTql6IcEa3mfD8tuBcwETsroNGCvGRWjKwNXha8rxMqlSvIbdCy1O3eJVxQ+7rDZbLnJLTJUS7JGTSP1C4FFV3dVfEwiGFM8RkbUEn/QLgL6I8knEhKwoky5WTUpWW+V7MW7DhpHI1DU6Eb9my0VtSJyJ1FX1DoIIxJ5hRRE5CbheVTeq6r0icitwP8En6QHCPRonHROyLCZFtJokTlm0KXQ/zqjFq0nD6C5aKGpBsMfwHllWInVVfYfj2FMEu4NEz7cCW4c2ZMwwIYsYF9FqiyhlMar3YlyyajRduLJooagZzWNyhawtwhWfnxkHkYoz6vfAhKvZRPfVQEELFkRbiqqmUvUO0Z8HLgGeUdUzHOfnCZIRPx4e2q6qH6/EmCYJ17gJUhrJ13yUkZfjlEF+XIUrjQYLmtFMqvbIbgA+Q5BbLI3vqeollVoxyg1nJkWkYPJ+HIwqc/ykCVcaJmiGJ5UKmap+N1y9Pl6Mu1g1SaBcjOr1N4+rGTRA0ILs97axZlNpwhzZa0TkhwQ5w7ao6sN1G9TDOIlW0wXKxahffxOv5mKvmZFC3UJ2P/CLqtoVkY3AN4DTXAVFZDOwGWD9+vV0Oh3vi8yu7bLwa57ly1z0WiKzR3VZ+I1OeoEW7Nc9u67Lwm923Cfret0LXHf2mC4Lr+8Mfq0GvEezx3ZZeEOnbjOGotvtFvr+l4EFezSbWoUsnmNMVe8Qkc+KyAmqusdRdhvh4r+5uTmdn5/3vs41N3XY8sOU8m3wuPbBwm922PL9+botGYqF3+yw5S/n6zZjYK9r4fUdttw1X6xSw7yIhTd02HL7fN1mDMXdV3Uo8v03xp9ahUxEXk6Q6VlF5CxgCvinyi/cJPFq43CfD2kpqkZNHZk0GiZey+ynuk1mLSDDqJGqw++/DMwTbGuwi2BF+hEAqnod8Gbg3SKySNClb1LV8ru7JqzBGkfBqvs1dWHCVX8KKhg7YVOEw0zXbYaRQtVRi5flnP8MQXj+eGBiNXrqzl1YN02xI8mYC5vRLOoO9mgv4yBaTRepJHVmjN9P/dsBNVW0fGhACP0wFNxY0xgxJmQ+tFm02iZWUP8WJ9Ac0WiKHWVhuRWNCjAhc9Em4WqjUEU0QbAimiAYTbBhlLTISwvC721BdFMxIYNmC9c4JA2OBGtUKZ58aIJoNMGGJtAiQTOayVTdBtTGvthfEziQ8tcmFlP+msD+xF8T7DB6mYDXRUROFpG7ReQREXlYRN4XHv8jEdktIg+GfxtT6l8d1tspIl8WEZN/Js0ja4JotU2cXDRFnLJoSofYFDvaxH4a550tlbSxJsG35wOqer+IHA3cJyJ3hef+o6oupFUUkQ3AVcDpqrpPRG4h2FX6hjIMazOTIWSj3D4kjonW6GiKYDTFjrYzpsONqvo08HT4eK+IPAJsKNDEKuBIETkErCXIUTvxTO7QYhW0dVgwbUiwqSKWHCasWzyaYsc40pDXVJniIDNefwQJIHbE/ja72gx3BnkVcG946L0i8iMR+byIHN9ng+puYAF4gkAMn1fVO6u437ZhQjYobZ3PaotYxWmSaEHz7Bl32vc671HVudjftmQBEVkHfA14f5hz9lrgnwNnEojUNY46xwOXAqcCJwFHicjl1d1GezAh88VEazQ0zduCFTuqylNo+DEmr72IHEEgYl9U1e0AqvozVT2sqkvAfwHOclS9EHhcVZ9V1UPAduDcUdndZCZjjmxQ2iBYbRAnF03vlJpu36BkZSdpw3xUTe+LlhTsISICfA54RFU/GTt+Yjh/BvBbwE5H9SeAc0RkLcGs/wXAjqGNGgNMyOI0WbiatAarKFHnU3eKpyyaalcRhr0Hn/ptELtmcx7wduAhEXkwPPZR4DIROZPgm/4T4N8CiMhJwPWqulFV7xWRWwn2cVwEHiDc2mrSMSFroni1XbDaQJtsjWiCzS4bJkDcytpYU1W/D4jj1B0p5Z8CNsaebyXYRcSIMblC1gQBa6tgQTM61SKYvdUxpqHyRnuYLCGrW7xMuEaH2Tt6xjgh8BJTHFyyXItNZTKErK48hSZco6VNNrfJ1kEwL80YIZWG34cL+54REVcEDhLwaRF5LFwI+OtV2jMS2hTqHqdpIe95NDFMP4822VoWk3a/Ri1U7ZHdQLAD9I0p5y8GTgv/ziZYFHh2xTaVS9sEC9rZsbTN5rbZWzUt99B0STiw3zbWbCqVCpmqfjdMw5LGpcCNqqrAPSJyXGI9RTNpm3i1sVM1m8eTBiYENtpP3XNkG4AnY893hceaJ2RtEq+2dahtszeirXbXTQu9M10SDu63YI+mUreQudZTqLNgkHhzM8D69evpdDreF5k9usvC+f7lsy2ph9ljuiy8vtN/YmnkpgzM7LFdFt7QadTrWoTZ47os/OtO3WYMxexLuixs6tRtxgoDzNJ3u91C339j/KlbyHYBJ8eez5KyLUGYeHMbwNzcnM7Pz3tf5JobOmz5jmf5hnpeC6/vsOUv5us2ozgxr2XhTR22bJ+vzZSBiNu/qcOWm+drM6UMGnsPBbyzuz/Uocj33xh/6hay2wi2LriZIMjj+VrmxxoqXj1DV23xvNo+3NZ2+9tKw+fOVIXFQ9N1m2GkUKmQiciXgXmC/Xl2EaRWOQJAVa8jSMuyEXgMeBG4skp7+miigLWxI22jzXHabv+40HAxM5pL1VGLl+WcV+A9VdrgpEkC1tZOtK12R7Td/nGlqWKmwtIBC79vKnUPLY6WpghYWzvRttod0Xb7J4WmipnRWCZDyJqwBUpbO9G22h3RdvsnlaaJ2ZLA/snoLtuI7RBdJW1NSdRWu6F9aauMdMbw/RORk0XkbhF5REQeFpH3hcf/OEzT96CI3BnuQ+aqf3VYb6eIfFlEmiT3tWFCVjZt7UTbaje023Yjm/F7TxeBD6jqrwLnAO8RkdOBT6jqv1DVM4FvAn+YrCgiG4CrgDlVPQOYBjaNzPIGY75yWbTxC9dGm6G9dhuD0YRhRqWUz124vOjp8PFeEXkE2KCqP44VO4r0tAGrgCNF5BCwlpR1t5OGCdkwtLFDbaPN0F67y6DMe2/LesQJIMxD+yrg3vD5fwCuAJ4HXpcsr6q7RWQBeALYB9ypqneOzOAGY0OLg9CmYay2zhm11e5BcW1LU9W9t/G1rdvOJQLp8PkL1s3uiP1tTjYnIuuArwHvV9UXAFT1D1T1ZOCLwHsddY4nSLR+KnAScJSIXF7ynbYS88iKUPeXqQhtsjWijTYPSpPudYx3dq6JPao6l3ZSRI4gELEvqup2R5EvAbcTJJCIcyHwuKo+G7azHTgXuKkUq1uMCZkPTep0smiLnXHaaPOgtOFem5yZvs65spJ2mRcRAT4HPKKqn4wdP01V/y58+kbgUUf1J4BzRGQtge93AbBjeKvajwlZFm3oeKA9dsZpo81FafM9NlXQ2vyaBpwHvB14SEQeDI99FPhdEXkFwSDmPwLvAgjD8K9X1Y2qeq+I3ArcTxD9+ABhIvVJx4QsjTZ8YdpgY5I22lyUcbrHJkQMjhGq+n3c21fdkVL+KYJ8tNHzrfQPOU48JmRJmt4JNd2+NPYz3hFzbX1ffDAxCz674/wetxwTsoimf0hLWscyUtpmb1HG/f7iNHWo0TAwIQtoaofUVLvyaKvdvoz7/WUxqd6ZeWSNZrKFrKkfzKbalUdb7fYhGhod53v0ZVLFzGgskylkTe2MmmpXHm2124dxvrdhMDEzGkTlmT1E5CIR+RsReUxEPuw4Py8iz4dZnx8Ukb5kmaXSxI6pTRkW4rTV7jzalvWiLibp9VGKZPYwRkylHpmITAN/Drwe2AX8QERuSyTIBPieql5SpS1A8754TbOnCG22PYtxvS/DGGOq9sjOAh5T1X9Q1YPAzQS5wkZLE+c2mmZPEdpsexbjel/G8Chw2PPPGDlVz5FtAJ6MPd8FnO0o9xoR+SHBlgRbVPXhZIEw8eZmgPXr19PpdLyNmD22y8Ib/MtXTtoGDRnMHtdl4U2d0k0pzBBrwWZf0mVhU6c0U0rD855mX9pl4YpOpaZUTSX3MOLU491ut9D33xh/qhYy1wr2ZDd+P/CLqtoVkY3AN4DT+iqpbiNMxzI3N6fz8/PeRlzzuQ5bbvcvXykD/upfeFOHLdvnSzWlMEN6LAubOmy5eb4UU0qjwD0tXNFhy43zlZkyCiq5hxEHfdz9hx2KfP9LoYmjOsYyVf+W2gWcHHs+S2IjOFV9QVW74eM7gCNE5ISK7aqHNn8R2mx7GuN4T4YxgVQtZD8AThORU0VkNcG23LfFC4jIy8OM0IjIWaFN/1SxXaOl7RFwbbbdRdvfD8Mweqh0aFFVF0XkvcC3gWng86r6sIi8Kzx/HfBm4N0iskgQvLpJVQeYRWoobe8w225/knG7nyYwCWvK2pgiboKofEF0OFx4R+LYdbHHnwE+U7UdtdD2D37b7Y8zTvdiGEYPk5nZYxS0veNsu/1xxulejHqwYI9GM+LAWcMwxo5xH1YsERE5WUTuFpFHRORhEXlfePwt4fMlEZnLqH91WG6niHxZROzVx4SsGuyXm2EYbhaBD6jqrwLnAO8RkdOBncCbgO+mVRSRDcBVwJyqnkEQd7CpepObjw0tGoZh5FHS0KKqPg08HT7eKyKPABtU9S6AMIA7i1XAkSJyCFhLYjnTpGIemTHemHdcLTawNTAicgrwKuBen/KquhtYAJ4gEMPnVfXOygxsESZkRj/W+RtGL1H4vc8fnCAiO2J/m5PNicg64GvA+1X1BR8TROR4gly1pwInAUeJyOVD3tlYYEOLZWMiYEwK5o2lsUdVswI2jiAQsS+q6vYC7V4IPK6qz4btbAfOBW4axthxwITMMAwjjyVK2WsszGL0OeARVf1kwepPAOeIyNrQmguAHcNb1X5saNEwjOKYNzYo5wFvB86PbSa8UUR+S0R2Aa8BbheRbwOIyEkicgeAqt4L3EqQaP0hgv57Wy130TDMIzMMwxgRqvp93LuCAHzdUf4pYGPs+VZgazXWtRcTsrJZQ/vnycbhHiLG6V6awiR6YwocqNsIIw0bWjTcjFNnNU73Ujf2WhoNxDyyKhgXL2Bc7gPG617qYpJFrKRgD6MazCOrinH50o/LfcB43cuosdfOaDAmZEY+49SJjdO9jII12GtmNJ7KhUxELhKRvxGRx0Tkw47zIiKfDs//SER+vWqbRsY4dQB2L5OHvU4rLBEEe/j8GSOnUiETkWngz4GLgdOBy8JMz3EuBk4L/zYD11Zp08gZp87A7mVyaOjro9+p2wKjiVQd7HEW8Jiq/gOAiNxMkCvsx7EylwI3qqoC94jIcSJyYpglejwYp0ADu5fxp2Ei1hjxWqzbACONqoVsA/Bk7Pku4GyPMhsItzowGsg4CUDUaY/L/QyDCZjRUqoWMtcKdh2gDGEG6c0A69evp9PpeBsxe2yXhTf4l6+EvjsqxuxxXRbe1CnFlFJYKl5l9iVdFjZ1SjelFDzuZ/alXRau6FRuSpXk3kPN4V+v/uWVx2lf8W63W+j7Xwol7UdmVEPVQrYLODn2fJb+jeB8yqCq2wjzis3Nzen8/Ly3EZ1Oh7e92b98E7F7qJ9Op8Pb3jJftxlDMS73UOT7b4w/Vf/++gFwmoicKiKrCbblvi1R5jbgijB68RyCzeJsWNEwDMPwolKPTFUXReS9wLeBaeDzqvqwiLwrPH8dcAdBUszHgBeBK6u0yTAMozA2tNhoKk9Rpap3EIhV/Nh1sccKvKdqOwzDMIzxxHItGoZh5KGYR9ZgLEWVYRjGCBGRz4vIMyKyM3bs10Tkr0TkIRH5CxE5JqXu1SLysIjsFJEvi0jDFk3UgwmZYRjGaLkBuChx7Hrgw6r6SoINNj+YrCQiG4CrgDlVPYMg7mBTtaa2AxMywzCMPKJgD5+/HFT1u8D/mzj8CuC74eO7gN9Oqb4KOFJEVgFrcSxVmkRMyAzDMOpnJ/DG8PFb6F1bC4Cq7gYWgCcIMh89r6p3jszCBiNB0GC7EJFngX8sUOUEYE9F5owKu4f6abv9MJn38Iuq+rJhLigi3wqv60Myidu2MKFDvL1TgG+GQ4SIyK8AnwZeSrC29ipVfWmizvHA14C3Ac8BXwVuVdWbit7PuNHKqMWiH0oR2aGqc1XZMwrsHuqn7faD3cOgqGpyTqvs9h8F/iWAiPwy8AZHsQuBx1X12bDcduBcYOKFzIYWDcMwakZEfiH8PwX8O+A6R7EngHNEZK2ICHAB8MjorGwuJmSGYRgjRES+DPwV8AoR2SUiv0uwV+PfAo8SBHD817DsSSJyB4Cq3gvcCtwPPETQf29zXGLiaOXQ4gCMw5tt91A/bbcf7B5qR1UvSzn1KUfZpwhS+EXPtwJbKzKttbQy2MMwDMMwImxo0TAMw2g1Yy9kInKRiPyNiDwmIh+u256iuNLZtAkROVlE7haRR8LUOu+r26aiiMgaEflrEflheA//vm6bBkFEpkXkARH5Zt22DIKI/CRM4fSgiOyo2x6jOYz10KKITAN/C7yeYAPPHwCXqeqPazWsACLyvwFd4MZozUmbEJETgRNV9X4RORq4D/jXLXsPBDhKVbsicgTwfeB9qnpPzaYVQkT+D2AOOEZVL6nbnqKIyE8I0jO1fR2cUTLj7pGdBTymqv+gqgeBm4FLa7apECnpbFqDqj6tqveHj/cShAtvqNeqYmhAN3x6RPjXql+AIjJLsDbp+rptMYyyGXch2wA8GXu+i5Z1ouNEmM3gVcC9NZtSmHBY7kHgGeCuMBS6Tfwn4EMEWQPbigJ3ish9IrK5bmOM5jDuQiaOY636JT0uiMg6gvQ671fVF+q2pyiqelhVzwRmgbNEpDXDvCJyCfCMqt5Xty1Dcp6q/jpwMfCecNjdMMZeyHbRm3xzFssWPXLCeaWvAV9U1e112zMMqvoc0KF/G44mcx7wxnCO6WbgfBFpXVqjcE0VqvoMwVYnZ9VrkdEUxl3IfgCcJiKnishqgr17bqvZpokiDJT4HPCIqn6ybnsGQUReJiLHhY+PJMh592itRhVAVT+iqrOqegrBd+A7qnp5zWYVQkSOCoOFEJGjCPIStjKS1yifsRYyVV0E3gt8myDI4BZVfbheq4qRks6mTZwHvJ3AC3gw/NuYV6lhnAjcLSI/IvhxdJeqtjKEvcWsB74vIj8E/hq4XVW/VbNNRkMY6/B7wzAMY/wZa4/MMAzDGH9MyAzDMIxWY0JmGIZhtBoTMsMwDKPVmJAZhmEYrcaEzDAMw2g1JmTGWCIi3xKR59q6ZYlhGP6YkBnjyicIFmIbhjHmmJAZrUFEfkNEfhRudHlUuMmlM3mvqv4lsHfEJhqGUQOr6jbAMHxR1R+IyG3A/wkcCdykqpZvzzAmHBMyo218nCDf4X7gqpptMQyjAdjQotE2XgKsA44G1tRsi2EYDcCEzGgb24CPAV8E/rRmWwzDaAA2tGi0BhG5AlhU1S+JyDTwP0XkfFX9jqPs94BfAdaJyC7gd1X12yM22TCMEWDbuBiGYRitxoYWDcMwjFZjQ4tGaxGRVwJfSBw+oKpn12GPYRj1YEOLhmEYRquxoUXDMAyj1ZiQGYZhGK3GhMwwDMNoNSZkhmEYRqsxITMMwzBazf8PGE3icBF38p0AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=600, data_for_other_variables={'t':4.})\n", + "fig = tp.utils.plot(model, lambda u : u, \n", + " plot_sampler, plot_type='contour_surface',\n", + " vmin=vmin, vmax=vmax)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "10a7c785-90da-4b62-964f-af7d816ed1bd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=600, data_for_other_variables={'t':8.})\n", + "fig = tp.utils.plot(model, lambda u : u, \n", + " plot_sampler, plot_type='contour_surface',\n", + " vmin=vmin, vmax=vmax)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "c3e6a8cf-6bd5-42d6-a3ac-16c4a64eb22b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=600, data_for_other_variables={'t':12.})\n", + "fig = tp.utils.plot(model, lambda u : u, plot_sampler, plot_type='contour_surface',\n", + " vmin=vmin, vmax=vmax)" + ] + }, + { + "cell_type": "markdown", + "id": "9d58e206-c27f-4ee6-8f4d-ddb1415c7221", + "metadata": {}, + "source": [ + "It is also possible to evaluate the model manually at torch Tensors. Say, we want to evaluate it on a spatial grid at some fixed time $t'= 6$." + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "id": "9ccbb9b3-6f6a-4a29-8dc7-c2360b2df7c9", + "metadata": {}, + "outputs": [], + "source": [ + "x_coords = torch.linspace(0, 5, 100)\n", + "y_coords = torch.linspace(0, 4, 80)\n", + "t_coords = torch.linspace(6, 6 , 1)\n", + "#t_coords = torch.linspace(0, 20, 120)\n", + "xs, ys, ts = torch.meshgrid([x_coords, y_coords, t_coords])\n", + "tensors = torch.stack([xs.flatten(), ys.flatten(), ts.flatten()], dim=1)" + ] + }, + { + "cell_type": "markdown", + "id": "26d9c9ba-77fe-4c21-af35-12e1376b113e", + "metadata": {}, + "source": [ + "The TorchPhysics model cannot be directly evaluated at Pytorch Tensors. Tensors must first be transformed into TorchPhysics Points, which is easy to achieve. We only need to which space the \"tensors\" above belong to. In our case, it belongs to the space $X*T$. ATTENTION: Since the spatial coordinates has been fed into \"tensors\" first, it is important to define the space as $X*T$ and NOT $T*X$!\n", + "For more information on the Point class please have a look at [space- and point-tutorial](https://torchphysics.readthedocs.io/en/latest/tutorial/tutorial_spaces_and_points.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "67c99cdd-70db-4465-9ec0-8278b7381fa6", + "metadata": {}, + "outputs": [], + "source": [ + "points = tp.spaces.Points(tensors, space=X*T)" + ] + }, + { + "cell_type": "markdown", + "id": "ce94a359-75dd-41e7-85b3-2000b2065054", + "metadata": {}, + "source": [ + "Now the model can be evaluated at those points by its forward() method. In order to use e.g. \"plt.imshow()\", we need to transform the output into a numpy array." + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "id": "854b969a-96f2-4088-b045-d1ca5cf0db64", + "metadata": {}, + "outputs": [], + "source": [ + "output = model.forward(tp.spaces.Points(tensors, space=X*T))\n", + "output = output.as_tensor.reshape(100, 80, 1).detach().numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "id": "70d30023-ca42-460a-9906-2bcc736016ce", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(np.rot90(output[:, :]), 'gray', vmin=vmin, vmax=vmax)\n", + "plt.show()" + ] + } + ], + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 9ffc2fd748548125fceb70b16677bee4035b5a87 Mon Sep 17 00:00:00 2001 From: kenaj123 <126678830+kenaj123@users.noreply.github.com> Date: Wed, 1 Mar 2023 14:17:37 +0100 Subject: [PATCH 09/30] Fixed typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Janek Gödeke --- examples/tutorial/Introduction_Tutorial_PINNs.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/tutorial/Introduction_Tutorial_PINNs.ipynb b/examples/tutorial/Introduction_Tutorial_PINNs.ipynb index 7071b468..01ab06da 100644 --- a/examples/tutorial/Introduction_Tutorial_PINNs.ipynb +++ b/examples/tutorial/Introduction_Tutorial_PINNs.ipynb @@ -529,7 +529,7 @@ "id": "2e0fad4c-2cfd-4c10-8e2f-0a3702a2eeac", "metadata": {}, "source": [ - "The reason that also the model is required for initializing a Condition object is, that it could be desireable in some [cases](https://github.com/TomF98/torchphysics/blob/main/examples/pinn/interface-jump.ipynb) to train different networks for different conditions of the PDE problem. (TODO: EXAMPLE?)" + "The reason that also the model is required for initializing a Condition object is, that it could be desireable in some [cases](https://github.com/TomF98/torchphysics/blob/main/examples/pinn/interface-jump.ipynb) to train different networks for different conditions of the PDE problem." ] }, { From 397095394d4797c40f4b522b8e293e341b203cad Mon Sep 17 00:00:00 2001 From: kenaj123 <126678830+kenaj123@users.noreply.github.com> Date: Wed, 1 Mar 2023 15:26:52 +0100 Subject: [PATCH 10/30] PINNs learning parameter dependency MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Janel Gödeke --- .../Tutorial_PINNs_Parameter_Dependency.ipynb | 546 ++++++++++++++++++ 1 file changed, 546 insertions(+) create mode 100644 examples/tutorial/Tutorial_PINNs_Parameter_Dependency.ipynb diff --git a/examples/tutorial/Tutorial_PINNs_Parameter_Dependency.ipynb b/examples/tutorial/Tutorial_PINNs_Parameter_Dependency.ipynb new file mode 100644 index 00000000..c23967f4 --- /dev/null +++ b/examples/tutorial/Tutorial_PINNs_Parameter_Dependency.ipynb @@ -0,0 +1,546 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "1ef6d147-2dd4-4547-9fb6-79b3758d7350", + "metadata": {}, + "outputs": [], + "source": [ + "import torchphysics as tp\n", + "import numpy as np\n", + "import torch\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "05faf0de-a2f3-4789-a076-3e17ab80b5d5", + "metadata": {}, + "source": [ + "# PINNs in TorchPhysics for Parameter-Dependent PDEs\n", + "In the previous [tutorial](https://github.com/TomF98/torchphysics/blob/main/examples/tutorial/Introduction_Tutorial_PINNs.ipynb), we solved a single PDE by PINNs in TorchPhysics. However, it is desirable to solve PDEs for different parameters choices simultaneously. Below, we want to illustrate that the PINN approach is also capable of solving parameter-dependent PDEs.\n", + "\n", + "Again, consider the time-dependent heat equation for a perfectly insulated room $\\Omega\\subset \\mathbb{R}^2$ in which a heater is turned on. We introduce the thermic diffusivity $\\color{red}{a \\in A:= [0.1, 1]}$ as well as the time $\\color{red}{p\\in P:=[3, 10]}$ at which the heater reaches its maximal temperature as parameters for the PDE.\n", + "$$\n", + "\\begin{cases}\n", + "\\frac{\\partial}{\\partial t} u(x,t) &= \\color{red}{a} \\Delta_x u(x,t) &&\\text{ on } \\Omega\\times I, \\\\\n", + "u(x, t) &= u_0 &&\\text{ on } \\Omega\\times \\{0\\},\\\\\n", + "u(x,t) &= h(t, \\color{red}{p}) &&\\text{ at } \\partial\\Omega_{heater}\\times I, \\\\\n", + "\\nabla_x u(x, t) \\cdot \\overset{\\rightarrow}{n}(x) &= 0 &&\\text{ at } (\\partial \\Omega \\setminus \\partial\\Omega_{heater}) \\times I.\n", + "\\end{cases}\n", + "$$\n", + "The initial room (and heater) temperature is $u_0 = 16$. The time domain is the interval $I = (0, 20)$, whereas the domain of the room is $\\Omega=(5,0) \\times (4,0)$. The heater is located at $\\partial\\Omega_{heater} = [1,3] \\times \\{4\\}$ and the temperature of the heater is described by the function $h$ defined below." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d6b5fdd2-67c1-4f7e-a185-9d515fb9f3f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "u_0 = 16 # initial temperature\n", + "u_heater_max = 40 # maximal temperature of the heater\n", + "\n", + "# heater temperature function\n", + "def h(t, p):\n", + " # p: time at which the heater reaches its maximal temperature\n", + " ht = u_0 + (u_heater_max - u_0) / p * t\n", + " ht[t>p] = u_heater_max\n", + " return ht\n", + "\n", + "# Visualize h(t, p) for fixed p\n", + "t = np.linspace(0, 20, 200)\n", + "p = 6\n", + "plt.plot(t, h(t, p))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cd62c045-b9f2-4da9-93fa-0f22fda25f5c", + "metadata": {}, + "source": [ + "Most of the code remains the same compared to the first Tutorial. In the following we rewrite the code from the first Tutorial and indicate where changes are required." + ] + }, + { + "cell_type": "markdown", + "id": "8f0db4a0-cace-4d21-845f-f34680880d7d", + "metadata": {}, + "source": [ + "# Translating the PDE Problem into the Language of TorchPhysics" + ] + }, + { + "cell_type": "markdown", + "id": "e8fe0433-82b7-4093-8f6f-8adf7e46ff5b", + "metadata": {}, + "source": [ + "### Step 1: Specify spaces and domains" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6af0dba0-d481-4566-a8b7-244098eee713", + "metadata": {}, + "outputs": [], + "source": [ + "# Input and output spaces\n", + "X = tp.spaces.R2(variable_name='x')\n", + "T = tp.spaces.R1('t')\n", + "U = tp.spaces.R1('u')\n", + "\n", + "# Domains\n", + "Omega = tp.domains.Parallelogram(space=X, origin=[0,0], corner_1=[5,0], corner_2=[0,4])\n", + "I = tp.domains.Interval(space=T, lower_bound=0, upper_bound=20)" + ] + }, + { + "cell_type": "markdown", + "id": "096fb96b-c3f2-4957-b7b5-6597da2f5040", + "metadata": {}, + "source": [ + "In addition, we need to define own TorchPhysics Spaces and Domains for the parameters $a\\in A\\subset \\mathbb{R}$ and $p\\in P \\subset\\mathbb{R}$." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "de756b96-3c0d-42d7-a74d-db387f448426", + "metadata": {}, + "outputs": [], + "source": [ + "# Parameter spaces\n", + "A_space = tp.spaces.R1('a')\n", + "P_space = tp.spaces.R1('p')\n", + "\n", + "A = tp.domains.Interval(A_space, 0.1, 1.)\n", + "P = tp.domains.Interval(P_space, 3, 10)" + ] + }, + { + "cell_type": "markdown", + "id": "a1676bc3-8dab-4ce4-84ff-f8fc29e8b829", + "metadata": {}, + "source": [ + "### Step 2: Define point samplers for different subsets of $\\overline{\\Omega\\times I\\times A \\times P}$\n", + "You may have noticed the little change in the caption of Step 2. Since the neural network should solve the PDE for every parameter $a\\in A$ and $p\\in P$, its input space must be $\\overline{\\Omega\\times I\\times A \\times P}$. Therefore, all samplers must sample points within this extended domain." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d428cf7f-89ee-4f3f-a1bf-822b82550a7e", + "metadata": {}, + "outputs": [], + "source": [ + "domain_pde_condition = Omega * I * A * P\n", + "sampler_pde_condition = tp.samplers.RandomUniformSampler(domain=domain_pde_condition, n_points=15000)" + ] + }, + { + "cell_type": "markdown", + "id": "9c9a3f41-54b4-4909-9826-49044cfa6bdc", + "metadata": {}, + "source": [ + "Similarly for the samplers corresponding to the initial and boundary conditions:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e780f5fa-5ebf-4731-8568-77116ea039f6", + "metadata": {}, + "outputs": [], + "source": [ + "domain_initial_condition = Omega * I.boundary_left * A * P\n", + "sampler_initial_condition = tp.samplers.RandomUniformSampler(domain_initial_condition, 5000)\n", + "\n", + "domain_boundary_condition = Omega.boundary * I * A * P\n", + "sampler_boundary_condition = tp.samplers.RandomUniformSampler(domain_boundary_condition, 5000)" + ] + }, + { + "cell_type": "markdown", + "id": "6b1b87f9-b6d6-44ec-8fb5-833ab466d89b", + "metadata": {}, + "source": [ + "### Step 3: Define residual functions\n", + "The residual for the pde condition requires the thermal diffusivity $a$ as an input." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c29f3f92-d613-470f-ab74-9369e071ea04", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_pde_condition(u, x, t, a):\n", + " return a * tp.utils.laplacian(u, x) - tp.utils.grad(u, t)" + ] + }, + { + "cell_type": "markdown", + "id": "e444a2e5-6fc6-4124-894c-1ba987153241", + "metadata": {}, + "source": [ + "The residual for the intial condition remains unchanged." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "65954de9-4c80-4d2a-be6e-0cd16ab82596", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_initial_condition(u):\n", + " return u - u_0" + ] + }, + { + "cell_type": "markdown", + "id": "97b9bfba-5cd3-400c-8c5a-4cd48b320c80", + "metadata": {}, + "source": [ + "The Dirichlet condition depends on $p$, the time when the heater reaches its maximal temperature." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c97e8bfe-1580-4bb8-bb1b-d4c874ef6244", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_dirichlet_condition(u, t, p):\n", + " return u - h(t, p)" + ] + }, + { + "cell_type": "markdown", + "id": "de441693-0870-43db-8d8d-38777a075432", + "metadata": {}, + "source": [ + "The Neumann conditions remains unchanged." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "17d5e293-57bd-4739-9518-a014f6df2b79", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_neumann_condition(u, x):\n", + " normal_vectors = Omega.boundary.normal(x)\n", + " normal_derivative = tp.utils.normal_derivative(u, normal_vectors, x)\n", + " return normal_derivative " + ] + }, + { + "cell_type": "markdown", + "id": "463e507e-d33b-4f8d-9149-c45356fdf236", + "metadata": {}, + "source": [ + "Of course, the residual of the combined boundary condition requires $p$ as an input, too." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4864c6ed-6f2b-4f80-bd6f-cd8ff3d8a809", + "metadata": {}, + "outputs": [], + "source": [ + "def residual_boundary_condition(u, x, t, p):\n", + " # Create boolean tensor indicating which points x belong to the dirichlet condition (heater location)\n", + " heater_location = (x[:, 0] >= 1 ) & (x[:, 0] <= 3) & (x[:, 1] >= 3.99) \n", + " # First compute Neumann residual everywhere, also at the heater position\n", + " residual = residual_neumann_condition(u, x)\n", + " # Now change residual at the heater to the Dirichlet residual\n", + " residual_h = residual_dirichlet_condition(u, t, p)\n", + " residual[heater_location] = residual_h[heater_location]\n", + " return residual" + ] + }, + { + "cell_type": "markdown", + "id": "0cc89ada-310b-4a84-bcc0-77baa7afca2c", + "metadata": {}, + "source": [ + "### Step 4: Define Neural Network\n", + "As already mentioned, the input of our model should belong to $\\overline{\\Omega\\times I\\times A\\times P}$. Moreover, we slightly increase the size of the fully connected layers, since this time the model needs to learn more." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "bdef3d80-90e6-47aa-95ce-6d735fd03f36", + "metadata": {}, + "outputs": [], + "source": [ + "normalization_layer = tp.models.NormalizationLayer(Omega*I*A*P)\n", + "\n", + "fcn_layer = tp.models.FCN(input_space=X*T*A_space*P_space, output_space=U, hidden = (80,80,50,50))\n", + "\n", + "model = tp.models.Sequential(normalization_layer, fcn_layer)" + ] + }, + { + "cell_type": "markdown", + "id": "17e3f8ab-bd6c-4f4f-94a6-030930458c0c", + "metadata": {}, + "source": [ + "### Step 5: Create TorchPhysics Conditions\n", + "Here, nothing needs to be changed." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "008c09a7-81f8-41b5-8c10-3892812740ad", + "metadata": {}, + "outputs": [], + "source": [ + "pde_condition = tp.conditions.PINNCondition(module =model, \n", + " sampler =sampler_pde_condition,\n", + " residual_fn=residual_pde_condition)\n", + "\n", + "initial_condition = tp.conditions.PINNCondition(module =model, \n", + " sampler =sampler_initial_condition,\n", + " residual_fn=residual_initial_condition)\n", + "\n", + "boundary_condition = tp.conditions.PINNCondition(module =model, \n", + " sampler =sampler_boundary_condition,\n", + " residual_fn=residual_boundary_condition)" + ] + }, + { + "cell_type": "markdown", + "id": "31d80c43-5879-401c-8212-0e4a5fd6514c", + "metadata": {}, + "source": [ + "# Training based on Pytorch Lightning \n", + "Also in the training part, everything remains as it was." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "bb76e892-bf53-4a01-adc5-74dddb770525", + "metadata": {}, + "outputs": [], + "source": [ + "import pytorch_lightning as pl\n", + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\" # select GPUs to use" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "60fb3653-7b2c-40cf-a19c-e82bc43ef0d2", + "metadata": {}, + "outputs": [], + "source": [ + "training_conditions = [pde_condition, initial_condition, boundary_condition]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "857c00e3-07c8-45c5-bc14-cc4397b2d1d9", + "metadata": {}, + "outputs": [], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.007)\n", + "\n", + "solver = tp.solver.Solver(train_conditions=training_conditions, optimizer_setting=optim)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "818dd812-62c5-4bac-b8bf-c0d2da14a53c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 13.6 K\n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "13.6 K Trainable params\n", + "0 Non-trainable params\n", + "13.6 K Total params\n", + "0.055 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "65efa1748b0d4585aecc1382d31110a1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Start the training\n", + "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", + " max_steps=500, # number of training steps\n", + " logger=False,\n", + " benchmark=True,\n", + " checkpoint_callback=False)\n", + "\n", + "trainer.fit(solver) # start training" + ] + }, + { + "cell_type": "markdown", + "id": "bac7c186-2be3-4ce0-a252-527ae5083019", + "metadata": {}, + "source": [ + "# Visualization\n", + "Of course, we could again use the plot() function from \"tp.utils\" to visualize the solution for fixed time $t$ and parameters $a, p$, like we did in the first PINNs Tutorial. However, it is to create an animation over time for different parameter choices. For this purpose we create an AnimationSampler (instead of a PlotSampler). " + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "9adc3684-2113-44e7-8d0c-eef2a1c34126", + "metadata": {}, + "outputs": [], + "source": [ + "a = 0.11\n", + "p = 4\n", + "plot_sampler = tp.samplers.AnimationSampler(plot_domain=Omega, animation_domain=I,\n", + " frame_number=20, n_points=600, \n", + " data_for_other_variables={'a':a, 'p':p})" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "583438b4-7bb1-4be7-a8aa-ebe809b66689", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, animation = tp.utils.animate(model, lambda u : u, plot_sampler, ani_type='contour_surface', ani_speed=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "0a74056f-222e-4335-84b8-37ff8626af43", + "metadata": {}, + "outputs": [], + "source": [ + "animation.save(f'animation_tut_2_a{a}_p{p}.gif')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c854bbd-a4e0-4b36-a9b3-bfe8b3c4850b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From e866185e66ecd9b1a8f6b0acc38168318c0e3df5 Mon Sep 17 00:00:00 2001 From: kenaj123 <126678830+kenaj123@users.noreply.github.com> Date: Wed, 1 Mar 2023 18:44:26 +0100 Subject: [PATCH 11/30] Foulder for new tutorials Foulder for Tutorials on PINNs, DeepONets, DeepRitz, etc. --- docs/tutorials_methods/Introduction_PINNs_Tutorial | 1 + 1 file changed, 1 insertion(+) create mode 100644 docs/tutorials_methods/Introduction_PINNs_Tutorial diff --git a/docs/tutorials_methods/Introduction_PINNs_Tutorial b/docs/tutorials_methods/Introduction_PINNs_Tutorial new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/docs/tutorials_methods/Introduction_PINNs_Tutorial @@ -0,0 +1 @@ + From 32e4e82810fba000126df9406838a8c43c8263ac Mon Sep 17 00:00:00 2001 From: kenaj123 <126678830+kenaj123@users.noreply.github.com> Date: Wed, 1 Mar 2023 18:48:10 +0100 Subject: [PATCH 12/30] Delete docs/tutorials_methods directory --- docs/tutorials_methods/Introduction_PINNs_Tutorial | 1 - 1 file changed, 1 deletion(-) delete mode 100644 docs/tutorials_methods/Introduction_PINNs_Tutorial diff --git a/docs/tutorials_methods/Introduction_PINNs_Tutorial b/docs/tutorials_methods/Introduction_PINNs_Tutorial deleted file mode 100644 index 8b137891..00000000 --- a/docs/tutorials_methods/Introduction_PINNs_Tutorial +++ /dev/null @@ -1 +0,0 @@ - From c30f2e35565dddd855faf00d4c4008186ea7b5a0 Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Wed, 29 Mar 2023 15:23:44 +0200 Subject: [PATCH 13/30] make torchphyiscs installable with pip Signed-off-by: Tom Freudenberg --- CHANGELOG.rst | 9 ++++---- README.rst | 23 ++++++++++++++++--- pyproject.toml | 4 ++-- setup.cfg | 20 +++++++++------- setup.py | 2 +- src/torchphysics/__init__.py | 1 + .../problem/domains/domain2D/__init__.py | 2 +- 7 files changed, 41 insertions(+), 20 deletions(-) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 226e6f59..162c44ca 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -1,10 +1,9 @@ ========= Changelog ========= +All notable changes to this project will be documented in this file. -Version 0.1 -=========== -- Feature A added -- FIX: nasty bug #1729 fixed -- add your changes here! +Version 1.0 +=========== +First official release of TorchPhysics on PyPI. diff --git a/README.rst b/README.rst index 5c94db52..bcd45090 100644 --- a/README.rst +++ b/README.rst @@ -78,13 +78,28 @@ to have a look at the following sections: Installation ============ -TorchPhysics can be installed by using: +TorchPhysics reqiueres the follwing dependencies to be installed: + +- PyTorch_ >=1.7.1 +- `PyTorch Lightning`_ >=1.3.4,<2.0.0 +- Numpy_ >=1.20.2 +- Matplotlib_ >=3.0.0 + +Installing TorchPhysics with ``pip``, automatically downloads everything that is needed: .. code-block:: python - pip install git+https://github.com/boschresearch/torchphysics + pip install torchphysics + +Additionally, to use the ``Shapely`` and ``Trimesh`` functionalites install the library +with the option ``all``: + +.. code-block:: python + + pip install torchphysics[all] + -If you want to change or add something to the code. You should first copy the repository and install +If you want to add functionalties or modify the code. We recommend to copy the repository and install it locally: .. code-block:: python @@ -92,6 +107,8 @@ it locally: git clone https://github.com/boschresearch/torchphysics pip install . +.. _Numpy: https://numpy.org/ +.. _Matplotlib: https://matplotlib.org/ About ===== diff --git a/pyproject.toml b/pyproject.toml index 2c63dbb2..7894902d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -3,6 +3,6 @@ requires = ["setuptools>=46.1.0", "setuptools_scm[toml]>=5", "wheel"] build-backend = "setuptools.build_meta" -[tool.setuptools_scm] +#[tool.setuptools_scm] # See configuration details in https://github.com/pypa/setuptools_scm -version_scheme = "no-guess-dev" +#version_scheme = "no-guess-dev" diff --git a/setup.cfg b/setup.cfg index 68764a24..098e8697 100644 --- a/setup.cfg +++ b/setup.cfg @@ -6,6 +6,7 @@ name = torchphysics description = PyTorch implementation of Deep Learning methods to solve differential equations author = Nick Heilenkötter, Tom Freudenberg +version = 1.0.0 author_email = nick7@uni-bremen.de, tomfre@uni-bremen.de license = Apache-2.0 long_description = file: README.rst @@ -13,9 +14,9 @@ long_description_content_type = text/x-rst; charset=UTF-8 url = https://github.com/boschresearch/torchphysics # Add here related links, for example: project_urls = - Documentation = https://pyscaffold.org/ -# Source = https://github.com/pyscaffold/pyscaffold/ -# Changelog = https://pyscaffold.org/en/latest/changelog.html + Documentation = https://torchphysics.readthedocs.io/en/latest/ + Source = https://github.com/boschresearch/torchphysics + Changelog = https://github.com/boschresearch/torchphysics/blob/main/CHANGELOG.rst # Tracker = https://github.com/pyscaffold/pyscaffold/issues # Conda-Forge = https://anaconda.org/conda-forge/pyscaffold # Download = https://pypi.org/project/PyScaffold/#files @@ -27,7 +28,7 @@ platforms = any # Add here all kinds of additional classifiers as defined under # https://pypi.python.org/pypi?%3Aaction=list_classifiers classifiers = - Development Status :: 4 - Beta + Development Status :: 5 - Production/Stable Programming Language :: Python @@ -46,16 +47,20 @@ package_dir = # new major versions. This works if the required packages follow Semantic Versioning. # For more information, check out https://semver.org/. install_requires = - torch>=1.7.1 - pytorch-lightning>=1.3.4 + torch>=1.7.1,<2.0.0 + pytorch-lightning>=1.3.4,<2.0.0 numpy>=1.20.2 - matplotlib>=3.4.2 + matplotlib>=3.0.0 + scipy>=1.6.3 importlib-metadata; python_version<"3.8" [options.packages.find] where = src exclude = tests + examples + docs + experiments [options.extras_require] # Add here additional requirements for extra features, to install with: @@ -64,7 +69,6 @@ all = trimesh>=3.9.19 shapely>=1.7.1 rtree>=0.9.7 - scipy>=1.6.3 networkx>=2.5.1 # Add here test requirements (semicolon/line-separated) diff --git a/setup.py b/setup.py index 77b7d7bf..993a724c 100644 --- a/setup.py +++ b/setup.py @@ -10,7 +10,7 @@ if __name__ == "__main__": try: - setup(use_scm_version={"version_scheme": "no-guess-dev"}) + setup(use_scm_version=False) #use_scm_version={"version_scheme": "no-guess-dev"} except: # noqa print( "\n\nAn error occurred while building the project, " diff --git a/src/torchphysics/__init__.py b/src/torchphysics/__init__.py index b8b54f16..542903f6 100644 --- a/src/torchphysics/__init__.py +++ b/src/torchphysics/__init__.py @@ -4,6 +4,7 @@ from .problem import samplers from .problem import conditions from .models import * +from .utils import * from .solver import Solver, OptimizerSetting if sys.version_info[:2] >= (3, 8): diff --git a/src/torchphysics/problem/domains/domain2D/__init__.py b/src/torchphysics/problem/domains/domain2D/__init__.py index 685038fa..d27c0193 100644 --- a/src/torchphysics/problem/domains/domain2D/__init__.py +++ b/src/torchphysics/problem/domains/domain2D/__init__.py @@ -1,4 +1,4 @@ from .circle import Circle from .parallelogram import Parallelogram from .triangle import Triangle -from .shapely_polygon import ShapelyPolygon \ No newline at end of file +#from .shapely_polygon import ShapelyPolygon \ No newline at end of file From 820c525812a3592388b4f10c1343e864912d8bb7 Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Wed, 29 Mar 2023 15:31:39 +0200 Subject: [PATCH 14/30] add install info to readme Signed-off-by: Tom Freudenberg --- README.rst | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/README.rst b/README.rst index bcd45090..e1bbd219 100644 --- a/README.rst +++ b/README.rst @@ -80,10 +80,11 @@ Installation ============ TorchPhysics reqiueres the follwing dependencies to be installed: -- PyTorch_ >=1.7.1 -- `PyTorch Lightning`_ >=1.3.4,<2.0.0 -- Numpy_ >=1.20.2 -- Matplotlib_ >=3.0.0 +- PyTorch_ >= 1.7.1, < 2.0.0 +- `PyTorch Lightning`_ >= 1.3.4, < 2.0.0 +- Numpy_ >= 1.20.2 +- Matplotlib_ >= 3.0.0 +- Scipy_ >= 1.6.3 Installing TorchPhysics with ``pip``, automatically downloads everything that is needed: @@ -91,7 +92,7 @@ Installing TorchPhysics with ``pip``, automatically downloads everything that is pip install torchphysics -Additionally, to use the ``Shapely`` and ``Trimesh`` functionalites install the library +Additionally, to use the ``Shapely`` and ``Trimesh`` functionalities, install the library with the option ``all``: .. code-block:: python @@ -99,8 +100,8 @@ with the option ``all``: pip install torchphysics[all] -If you want to add functionalties or modify the code. We recommend to copy the repository and install -it locally: +If you want to add functionalities or modify the code. We recommend copying the +repository and install it locally: .. code-block:: python @@ -108,7 +109,8 @@ it locally: pip install . .. _Numpy: https://numpy.org/ -.. _Matplotlib: https://matplotlib.org/ +.. _Matplotlib: https://matplotlib.org/ +.. _Scipy: https://scipy.org/ About ===== From c140226764142c41efaa004ed62415c4816aad0a Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Wed, 12 Apr 2023 12:11:27 +0200 Subject: [PATCH 15/30] Add example for inverse DeepONet Signed-off-by: Tom Freudenberg --- examples/deeponet/inverse_ode.ipynb | 470 ++++++++++++++++++++++++++++ 1 file changed, 470 insertions(+) create mode 100644 examples/deeponet/inverse_ode.ipynb diff --git a/examples/deeponet/inverse_ode.ipynb b/examples/deeponet/inverse_ode.ipynb new file mode 100644 index 00000000..a92fb0fd --- /dev/null +++ b/examples/deeponet/inverse_ode.ipynb @@ -0,0 +1,470 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Inverse DeepONet\n", + "In this notebook, we present the learning of the inverse operator, that maps solution data to some input data. \n", + "To keep things simple we again consider the ODE:\n", + "\\begin{align*}\n", + " \\partial_t u(t) &= f(t), \\text{ in } [0, 1] \\\\\n", + " u(0) &= 0\n", + "\\end{align*}\n", + "for different functions, $f$. (Learning the differential operator)\n", + "\n", + "For a non physics DeepONet one needs a data pair of input data and expected solution, for the training of the inverse operator.\n", + "The training would then consist of a fitting procedure.\n", + "\n", + "If we want to include physics into the training's loss, one generally needs some derivatives of the solution (which is only given by discrete values). To compute them, one can either apply some finite difference scheme or use one additional DeepONet to first interpolate the data and then train a second network for the inverse operator using the first DeepONet and a physics loss.\n", + "\n", + "Here we demonstrate the first option. The physics informed inverse DeepONet will be shown in a different example.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n", + "import torch\n", + "import numpy as np\n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The generall parameter and variable definition is the same as in the forward problem:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Spaces \n", + "T = tp.spaces.R1('t') # input variable\n", + "U = tp.spaces.R1('u') # function output space name\n", + "K = tp.spaces.R1('k') # parameter\n", + "F = tp.spaces.R1('f') # output variable\n", + "# Domains\n", + "T_int = tp.domains.Interval(T, 0, 1)\n", + "K_int = tp.domains.Interval(K, 0, 6) # Parameters will be scalar values (need to create some training data)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Defining function set\n", + "Fn_space = tp.spaces.FunctionSpace(T_int, U)\n", + "\n", + "# Here some rhs functions that we consider in our example and network should output\n", + "def f1(k, t):\n", + " return k*t\n", + "\n", + "def f2(k, t):\n", + " return k*t**2\n", + "\n", + "def f3(k, t):\n", + " return k*torch.cos(k*t)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Model\n", + "dis_sampler = tp.samplers.GridSampler(T_int, 50).make_static()\n", + "trunk_net = tp.models.FCTrunkNet(T, F, hidden=(30, 30), output_neurons=50)\n", + "branch_net = tp.models.FCBranchNet(Fn_space, F, output_neurons=50, \n", + " hidden=(50, 50), \n", + " discretization_sampler=dis_sampler)\n", + "model = tp.models.DeepONet(trunk_net, branch_net)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we create some data, consisting of data functions (the defined **f** above) and the expected solutions of our ODE. For our example, we can compute them analytically.\n", + "\n", + "We evaluate both the solution functions only at the points of the discretization sampler, such they can be used as the branch input, while the data functions could be evaluated at arbitrary points in the interval.\n", + "\n", + "If the corresponding data would be available in some different kind of manner (e.g. measurements), one would skip this step." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# create evaluation points\n", + "eval_points = dis_sampler.sample_points().as_tensor\n", + "time_sampler = tp.samplers.GridSampler(T_int, n_points=1000)\n", + "trunk_input_points = time_sampler.sample_points().as_tensor\n", + "# Define expected solutions for the rhs of cell 3 (the different f functions)\n", + "def u1(k, t):\n", + " return k/2.0 * t**2\n", + "\n", + "def u2(k, t):\n", + " return k/3.0 * t**3\n", + "\n", + "def u3(k, t):\n", + " return torch.sin(k*t)\n", + "\n", + "# create some dataset:\n", + "num_data_points = 50000 # number of different data pairs\n", + "f_list = [f1, f2, f3]\n", + "u_list = [u1, u2, u3]\n", + "param_sampler = tp.samplers.RandomUniformSampler(K_int, n_points=num_data_points)\n", + "u_data_tensor = torch.zeros((num_data_points, len(eval_points), 1)) # tensor for the solution\n", + "f_data_tensor = torch.zeros((num_data_points, len(trunk_input_points), 1)) # tensor for the rhs\n", + "\n", + "param_tensor = param_sampler.sample_points().as_tensor\n", + "data_idx = 0\n", + "for param in param_tensor:\n", + " rand_idx = np.random.randint(0, 3) # pick one of our the functions\n", + " # evaluate the functions\n", + " u_data_tensor[data_idx] = u_list[rand_idx](param, eval_points)\n", + " f_data_tensor[data_idx] = f_list[rand_idx](param, trunk_input_points)\n", + " data_idx += 1" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now some data is available, which can be used to train the inverse operator. For a data fitting task the **tp.utils.DeepONetDataLoader** and **tp.conditions.DeepONetDataCondition** are available. \n", + "\n", + "The Dataloader needs the data inputs in the follwing structure:\n", + "\n", + " - branch_data: A tensor containing the branch inputs in the shape [number of data functions, input dim of Branchnet, dimension of function space]\n", + " - trunk_data: A tensor containing the input data for the trunk network. Here are two different shapes possible:\n", + "\n", + " 1) Every branch input function uses the same trunk values, then we can pass in\n", + " the shape: [number of trunk points, input dimension of trunk net]\n", + " This can speed up the trainings process. And is possible in our case.\n", + " 2) Or every branch function has different input values for the trunk net, then we \n", + " need the shape: \n", + " [number of data functions, number of trunk points, input dimension of Trunknet]\n", + " If this is the case, remember to set **trunk_input_copied = false** inside\n", + " the trunk net, to get the right trainings process. \n", + " - output_data : A tensor containing the expected output of the network. The shape of the data should be: \n", + " [number of data functions, number of trunk points, expected output dimension].\n", + "\n", + "Our previously created data is already in the correct shape." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "data_loader = tp.utils.DeepONetDataLoader(branch_data=u_data_tensor, trunk_data=trunk_input_points, \n", + " output_data=f_data_tensor, branch_space=U, trunk_space=T, \n", + " output_space=F, branch_batch_size=25000, trunk_batch_size=len(eval_points),\n", + " shuffle_trunk = False)\n", + "\n", + "# The DataCondition then handles everything for the training, just like in the PINN case.\n", + "# Via the keyword \"norm\" and \"root\" we can specify which norm should be used for computing the loss. Here we apply the L2 norm.\n", + "data_condition = tp.conditions.DeepONetDataCondition(model, data_loader, norm=2, root=2)\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can start the trainig" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [1]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 10.2 K\n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "10.2 K Trainable params\n", + "0 Non-trainable params\n", + "10.2 K Total params\n", + "0.041 Total estimated model params size (MB)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c321590cbc654d09a34db65f5a80fb5d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "88c53926d316487e836634cc0892f272", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.0005)\n", + "\n", + "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus='-1' if torch.cuda.is_available() else None,\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=10000,\n", + " logger=False,\n", + " checkpoint_callback=False\n", + " )\n", + "\n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [1]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 10.2 K\n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "10.2 K Trainable params\n", + "0 Non-trainable params\n", + "10.2 K Total params\n", + "0.041 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f2c1d0a05b964c498eab96518f8f5e21", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2ad83fe996454ae6927d9b01c96070de", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.00005)\n", + "\n", + "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus='-1' if torch.cuda.is_available() else None,\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=1000,\n", + " logger=False,\n", + " checkpoint_callback=False\n", + " )\n", + "\n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD6CAYAAACxrrxPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA4uklEQVR4nO3dd1xW5f/H8dclUwFxoKg4QMWBICgo7iRn5SjX13KkX9PM9JsNy771VdO2tkxtmGU2tFJTc+bCvcAtLhREnAguQOZ9/f64yR8i4xaBmxs+z8eDR5z7XOfcn4ub3hyvc851lNYaIYQQlq+MuQsQQghRMCTQhRCihJBAF0KIEkICXQghSggJdCGEKCEk0IUQooTIM9CVUt8rpa4qpY7msH6QUuqwUuqIUmqnUsq34MsUQgiRF5XXdehKqQ5APLBAa+2dzfo2wHGt9XWl1GPAFK11YF5v7OLiot3d3fNVdEJCAg4ODvna1lJJn0sH6XPp8DB9Dg0Nvaa1rpLdOuu8NtZab1VKueeyfmemxd1ATVOKcnd3JyQkxJSm9wkODqZjx4752tZSSZ9LB+lz6fAwfVZKnctpXUGPoY8A1hTwPoUQQpggzyEXgIwj9JXZDblkahMEzAHaaa1jc2gzChgF4Orq6r9o0aL81Ex8fDyOjo752tZSSZ9LB+lz6fAwfQ4KCgrVWgdku1JrnecX4A4czWV9U+AM0MCU/Wmt8ff31/m1efPmfG9rqaTPpYP0uXR4mD4DITqHXM1zDD0vSqnawFJgiNb61MPsKzU1lejoaJKSknJt5+zszPHjxx/mrSxOSe+zvb09NWvWxMbGxtylCGGx8gx0pdRCoCPgopSKBiYDNgBa66+BSUBlYI5SCiBN5/TPgTxER0fj5OSEu7s7GfvK1u3bt3FycsrPW1isktxnrTWxsbFER0fj4eFh7nKEsFimXOXydB7rnwOeK4hikpKS8gxzUfIopahcuTIxMTHmLkUIi1bs7hSVMC+d5HMX4uEVu0AXQogSKz0Vtn2K063ThbJ7CfQslFK8+uqrd5dnzJjBlClTct0mODiYnTt35tomP+bPn8/YsWMLdJ83btxgzpw5D7WPZcuWERYWVkAVCVFKXDoEcx+Fje9QJabg8wIk0O9jZ2fH0qVLuXbtmsnbFEagp6WlFej+/iGBLkQRS02CjVPh2yC4fRkGLOBsvWcL5a0k0LOwtrZm1KhRfPbZZ/eti4mJoW/fvrRo0YIWLVqwY8cOIiMj+frrr/nss8/w8/Njy5YteHh4oLXmxo0bWFlZsXXrVgA6dOjA6dOniYuL48knn6Rp06a0atWKw4cPAzBlyhSGDBlC27ZtGTJkyD3vvXbtWlq3bn3fH5rc9jVjxoy77by9vYmMjGTixImcOXMGPz8/JkyYQHBwMB06dOCJJ56gYcOGjB49GoPBAHDPjQ+LFy9m2LBh7Ny5kxUrVjBhwgT8/Pw4c+ZMAfzUhSihonbD1+1g2yfg+zSM3QtevQvt7R76OvTC8s5fxwi7eCvbdenp6VhZWT3wPr1qlGdyzyZ5tnvxxRdp2rQpr7/++j2vv/TSS7z88su0a9eOqKgounXrxvHjxxk9ejSOjo689tprADRs2JCwsDAiIiJo3rw527ZtIzAwkPPnz+Pp6cm4ceNo1qwZy5YtY9OmTQwdOpSDBw8CEBYWxvbt2ylbtizz588H4M8//+Szzz5j9erVVKxY8Z6aJk+enOO+svPhhx9y9OjRu22Cg4PZu3cvYWFh1KlTh+7du7N06VL69euX7fZt2rShV69e9OjRI8c2QpR6ybeNR+V754JzLRi8FOp3KvS3LbaBbk7ly5dn6NChzJw5k7Jly959fcOGDfcMNdy6dYv4+Pj7tm/fvj1bt24lIiKCN998k7lz5/LII4/QokULALZv386SJUsAePTRR4mNjeXWLeMfr169et3znps2bSIkJIQlS5bcF+Z57ctULVu2pG7dugA8/fTTbN++XcJaiPwK3wB/jYeb0RD4PDz6P7ArmqkNim2g53YkXRQ32YwfP57mzZszfPjwu68ZDAZ2796Nvb19rtt26NCBr776iosXLzJ16lSmT59OcHAw7du3z/N9s06pWa9ePc6ePUt4eDhubm4m129tbX136ATI9e7brJcM/rOc+fW87t4VotRLjIN1b8GhX8GlAfx7LdRuVaQlyBh6DipVqsSAAQOYN2/e3de6du3Kl19+eXf5n2ELJycnbt++fff1li1bsnPnTsqUKYO9vT1+fn588803dOjQATAewf/yyy+AccjDxcWF8uXLZ1tHnTp1WLJkCc8//zzHjh27b31O+3J3d2f//v0A7N+/n4iIiGxrBdi7dy8REREYDAZ+++032rVrB4CrqyvHjx/HYDDw559/3m2f3T6EKNXClsPsQDj8G7R/DZ7fVuRhDhLouXr11VfvOQk5c+ZMQkJCaNq0KV5eXnz99dcA9OzZkz///BM/Pz+2bduGnZ0dtWrVolUr4wfavn17bt++jY+PD2A8YRkaGkrTpk2ZOHEiP/74Y651NGrUiO+++47+/fvfdxIyp3317duXuLg4mjRpwqxZs2jQoAEAlStXpm3btnh7ezNhwgQAWrRowdixY2ncuDEeHh489dRTgHG8vUePHrRp04bq1avffc+BAwcyffp0mjVrJidFRel2+zL8Nhh+Hwrlq8OoYOj0P7DJ/V/xhSanWbsK+yu72RbDwsJMmm3s1q1bJrUrSQqrz5s3b9ZPPPFEoez7QWX9/GUWvtLBIvtsMGi9/yetP6il9dQqWm/7VOu0VJM3L7azLQohRKly/Rz89RKc3Qy120CvL8GlvrmrAorxSVFRNDp27FjqHv8lRL4Y0o2XIW6cCkrB4zMgYASUKT4j1xLoQgiRl5iTsGIcnN8D9TtDj8+hQi1zV3UfCXQhhMhJeirs+By2fAy2DvDUt9B0gPEIvRiSQBdCiOxcPADLx8GVI9DkKXhsOjhWMXdVuZJAF0KIzFLvQPCHsPNLcKgC//oFGvcwd1UmKT6j+cXIsmXLUEpx4sSJh9rPsGHDWLx4ca5t3n///XuW27Rpk6/3yjoZV34EBwfTo0fuv7hZZ2u8ePGiTBMgSo7IHfBVW+Mwi98z8OIeiwlzkEDP1sKFC2nXrh0LFy4s9PfKGuiFMa96Qcoa6DVq1Mjzj5YQxV7SLVj1Ksx/HAxpMHQ59J4FZSsU+FtdT0jhVrIu8P2CBPp94uPj2b59O/PmzWPRokV3Xw8ODqZjx47069ePRo0aMWjQIIzX+MPUqVNp0aIF3t7ejBo16u7r/9i0aRNPPvnk3eX169fz1FNPMXHiRO7cuYOfnx+DBg0C7p2y9qOPPsLHxwdfX18mT54MwNy5c2nRogW+vr707duXxMTEXPvzxx9/4O3tja+v792pB5KSkhg+fDg+Pj40a9aMzZs337edqdPvRkZG4u3tnet+58+fT58+fejevTuenp73zWIphFmdXg9zWsO+edBqDIzZBXU7FuhbRMUmMnfrWfp/vRP/d9fz97nUAt3/P4rvGPqaiXD5SLaryqangVU+Sq/mA499mGuT5cuX0717dxo0aEDlypUJDQ3F398fgAMHDnDs2DFq1KhB27Zt2bFjB+3atWPs2LFMmjQJgCFDhrBy5Up69ux5d59BQUGMGTOGmJgYqlSpwg8//MC///1vevbsyaxZs7Kd7nbNmjUsX76cPXv2UK5cOc6dOwdAnz59GDlyJABvv/028+bNY9y4cTn2Z+rUqaxbtw43Nzdu3LgBwOzZs1FKceTIEU6cOEHXrl05deqUST/CrNPvRkZG3l2X234PHjzIgQMHsLOzo2HDhowbN45atYrfZV+iFEmMg7VvwuFFUKURjFgPtVoUyK611py8cpu1Ry+z7tgVjl8yzoDauHp5xgbVp0ryhQJ5n6zkCD2LhQsXMnDgQMA4Z0nmYZeWLVtSs2ZNypQpg5+f390w27x5M4GBgfj4+LBp06b7JtFSSjFkyBB+/vlnbty4wa5du3jsscdyrWPDhg0MHz6ccuXKAcbJwgCOHj1K+/bt8fHx4Zdffsl2wq7M2rZty7Bhw5g7dy7p6emAccrdwYMHA8Z5YurUqWNyoOcmt/126tQJZ2dn7O3t8fLyuvsHSogipzUcXQqzWsDRxfDIG/D81ocOc601YRdv8cGa43ScEUz3z7fxxcbTONpZ8fYTjdk6IYg1L7Xnla4NqeVUONFbfI/QczmSvlNI0+fGxcWxadMmjhw5glKK9PR0lFJMnz4dMD6e7h9WVlakpaWRlJTEmDFjCAkJoVatWkyZMiXbqWaHDx9Oz549sbe3p3///lhb5+9HP2zYMJYtW4avry/z588nODg41/Zff/01e/bsYdWqVfj7+xMaGmrS+zzI9LumyO5nJ0SRu3XJOFZ+chXUaAa9lkM174fa5fm4RJYfvMDygxc5fTUe6zKKNvVdeL5DPTp7VaWqU9FN1CVH6JksXryYIUOGcO7cOSIjIzl//jweHh5s27Ytx23+CToXFxfi4+NzPEFYo0YNatSowbvvvnvPHOs2Njakpt4/ntalSxd++OGHu2PkcXFxgHEu+OrVq5Oamnp32tzcnDlzhsDAQKZOnUqVKlU4f/78PVPunjp1iqioKBo2bHjPdg8y/e4/TNmvEGahNexfYJzi9sxG6DINRmzId5jHJaTw485I+szZQfuPNzPj71NULGfLu096s/etziz4d0ueCaxdpGEOxfkI3QwWLlzIG2+8cc9rffv2ZeHChfzrX//KdpsKFSowcuRIvL29qVat2t2nEmVn0KBBxMTE0Lhx47uvjRo1iqZNm9K8efN7Arp79+4cPHiQgIAAbG1t6dy5MzNmzGDatGkEBgZSpUoVAgMD85yXfMKECZw+fRqtNZ06dcLX15dGjRrxwgsv4OPjg7W1NfPnz7/nCPqffi9YsIAmTZoQGBiY7fS7jz32GC+++OLdbcaMGZPnfoUocnER8Nd/IGIr1GkHvWZC5XoPvJt0g2Z7+DV+2xfF+rArpKZrGlVz4o3ujejpW52aFcsVQvEPRmW9IuO+Bkp9D/QArmqt7/tzpoyPtfkCeBxIBIZprffn9cYBAQE6JCTknteOHz9+T9jlpCieWFQYxo4dS7NmzRgxYsQDb2upfX4QWT//f64sKk2kzwXIkA57voFN00BZQdep0HzYA0+mdT4ukT9Co1kccp6LN5OoWM6GPs1r0j+gJo2qZf9gmrw8TJ+VUqFa64Ds1plyhD4fmAUsyGH9Y4Bnxlcg8FXGf0Um/v7+ODg48Mknn5i7FCFKvqvHYflYuBACnt2gx2fgbPojHNPSDWw4fpVf9pxje7jxITftPavw1hNedPaqip31gz+kvijkGeha661KKfdcmvQGFmRMvL5bKVVBKVVda32poIosCUw9GSmEeAhpKbD9M9g6HezLQ9954N3X5Mm0YuOTWbTvPL/sPsfFm0nUcLbnpU6e9A+ohVuFsnnvwMwKYgzdDTifaTk647V8BbrW+r6HFouSL6+hPyHydCHUOJnW1WPg3Q8e+wgcXEza9HD0DebvjGTloUukpBtoW78yk3s1oVOjqlhbWc61I3mOoQNkHKGvzGEMfSXwodZ6e8byRuANrXVINm1HAaMAXF1d/TPfiQnGuyRdXV1xdnbONdTT09Oxsiqe/+QpLCW5z1prbt68yZUrV4iPj7/7enx8/D13zpYG0ucHVyY9GffIX6l1fgUpthU51WA0sS4t89wu3aDZdzmdv8+lcvamATsraOtmTafaNrg5Fm6IP0yfg4KCHmoMPS8XgMy3/NXMeO0+WutvgW/BeFI060mB1NRUoqOjuXAh97uokpKSsLc300NYzaSk99ne3h5fX19sbGzuviYnCEuHh+pzxDb4ayLEnQX/Ydh1mYqPvXOumyQkp/HbvvPM2x7BhRvJ1HVxYErPOvTxr0l5e5tcty0ohfU5F0SgrwDGKqUWYTwZejO/4+c2NjZ4eHjk2S44OJhmzZrl5y0sVmnssxA5SroJ6ydD6A9Q0QOe/Qs8OuS6ydXbSfy4M5Kfd0dx804qLdwrMiVjWKVMmZIxzJtnoCulFgIdARelVDQwGbAB0Fp/DazGeMliOMbLFodnvychhCgAJ9fCypch/jK0GQcd/wu2OV8DfiYmnu+2nWXJ/gukphvo6uXKqA718K9TsQiLLhqmXOXydB7rNfBibm2EEOKhJVyDNW8Y51+p6gX/+hlq+ufY/OTl23y56TSrjlzCxqoM/fxr8lw7D+pWKbnnKOROUSFE8aY1HF0Ca143zlve8b/Q7mWwts22+bGLN/lyYzhrj13GwdaK0Y/UY0Q7D1wcS/5dyxLoQoji6+YFWPUKnFoLbv7Qaxa4emXb9ND5G3y56TQbjl/Fyd6a/zxan+FtPajokH3wl0QS6EKI4sdggP0/wvpJkJ4K3d6HwNFQ5v5Ld0PPXWfmxtNsORWDc1kbXunSgGfbuONctmiuWClOJNCFEMVL7Bn46yWI3Ga8cqXnF1Cp7n3Njl28ySd/n2LTiatUcrDl9e4NGdKqDk5FdOlhcSSBLoQoHtLTYPcc2PweWNlCz5nQfOh9t+2fiYnn0/WnWHX4EuXtrZnQrSHD2rjjYCdxJj8BIYT5XTlmnEzr4n5o+Dg88QmUr3FPk+jriXyx4TRL9kdjb2PFuEfr81z7uqVyaCUnEuhCCPNJS8Y94lfYugTsK0C/76FJn3uOyq/eTmL2pnB+3RuFUophbTwYE1SvVFy18qAk0IUQ5hEdAsvH4h5zHJr+C7p9AA6V766+nZTKN1vO8t32s6SmawYE1GTco57UsIBZD81FAl0IUbRSEmDTe8bx8vI1OOzzP5r2ee3u6tR0Awv3RvHFhtPEJqTQ07cGr3ZpgLuLgxmLtgwS6EKIonN2i/FxcNcjIWAEdJ5C3G7jA8601qw7dpmP1p4k4loCrepW4ofHG9O0ZgWzlmxJJNCFEIXvzg1Y/z/jg5or1YNhq8G97d3VoefieH/1CULPXad+VUfmPRvAo42qyrMRHpAEuhCicJ1YBStfgYSr0PYl6Pgm2BjHwSOuJfDlgSRC1+6iipMdH/Txob9/TYt6qERxIoEuhCgc8THG+VeOLQVXb3h6Ibg1ByAuIYUvNpzilz1RWCnNy50bMLKDB+VsJZIehvz0hBAFS2s4/DusfcN4AjTobWg3HqxsSE03sGDXOb7YcIqElHQGtqhFy3LX6N3Z09xVlwgS6EKIgnMz2jhX+em/oWYL42RaVRsBsPnEVaatCuNsTALtPV34Xw8vGrg6ERwcbN6aSxAJdCHEwzMYIPR741OEtAG6fwQtR0IZK8Kv3mbayuNsORWDh4uDnPAsRBLoQoiHcy0cVoyDqJ1Qt6NxMq2K7txITOHzDSf4afc5ytla8fYTjRna2h1baznhWVgk0IUQ+ZOeBrtmQfAHYG0HvWeD3yDSDJpfd0Xy6fpT3LqTysCWtXm1SwMqy636hU4CXQjx4C4fgeUvwqVD0KiHcTItp2psOx3DtJVhnLoST6u6lZjUowleNcqbu9pSQwJdCGG6tGTYOh22fwZlK0L/H8GrNxGxiby3dB8bjl+ldqVyfD3Yn25NXGWcvIhJoAshTBO1xzhWfu0k+D4D3d4jwao8s9ad5LttZ7G1KsMb3RsxvK079jb3P1lIFD4JdCFE7pLjYdM02PMNONeEwUvQ9Trx1+FLvL/qAJdvJdG3eU3eeKwhVZ3szV1tqSaBLoTI2ZlNxsfB3YiClqOg0yROXodJ3+5mT0QcTWqUZ/agZvjXqWTuSgUS6EKI7Ny5DuvehoM/Q2VPGL6Wm1UD+PzvUyzYdQ4ne2vee8qbgS1qY1VGxsmLCwl0IcS9jv8Fq16FhGvQ7hUMHV5nyeFrfPRTMLEJKTzTsjavdW1IRQdbc1cqspBAF0IY3b4CayZA2HKo5gPP/M4RgweTvtvPgagbNKtdgfnDW+Lt5mzuSkUOTAp0pVR34AvACvhOa/1hlvW1gR+BChltJmqtVxdsqUKIQqE1HFoIa9+E1DvQaRJxvqOZvuEsi/Ztp7KDLTP6+9KnmRtlZHilWMsz0JVSVsBsoAsQDexTSq3QWodlavY28LvW+iullBewGnAvhHqFEAXpRhT8NR7ObIRarUjvOZNfz9oz47MdxCenMbyNB+O7eFLe3sbclQoTmHKE3hII11qfBVBKLQJ6A5kDXQP/3A7mDFwsyCKFEAXMYIB938GGKcblx6YT6tqH/y08TtilW7SuW5kpvZrQsJqTWcsUD0ZprXNvoFQ/oLvW+rmM5SFAoNZ6bKY21YG/gYqAA9BZax2azb5GAaMAXF1d/RctWpSvouPj43F0dMzXtpZK+lw6FEWfyyZG0+jELJxvHSeuYjP2eYxmQWRFdlxMo5K9YmBDW1pUsyqyuzzlc34wQUFBoVrrgOzWFdRJ0aeB+VrrT5RSrYGflFLeWmtD5kZa62+BbwECAgJ0x44d8/VmwcHB5HdbSyV9Lh0Ktc/pqbBzJoR+BDZlSes1h6Xxrfh8YzjJaemM6ViPF4Pq42BXtNdKyOdccEz55C4AtTIt18x4LbMRQHcArfUupZQ94AJcLYgihRAP6dIh42Ral4+AV2/2N/kvE/++wqkrJ+jYsAqTenhRt0rpOkouiUwJ9H2Ap1LKA2OQDwSeydImCugEzFdKNQbsgZiCLFQIkQ+pSbDlQ9gxExxcuNnre945XY+lP53BrUJZvh3iTxcvmUSrpMgz0LXWaUqpscA6jJckfq+1PqaUmgqEaK1XAK8Cc5VSL2M8QTpM5zU4L4QoXOd2wYqxEBuOwW8Qv1cazXsrLpGUepEXg+oxNsiTsrYyiVZJYtJgWcY15auzvDYp0/dhQNuCLU0IkS/Jt2HDO7BvLlSoTXi3nxgfUpGju8/Ttn5l3unlTf2qMrxSEsmdokKUJOEbjNeV34wmqflIPkjux4IVsVR1SubLp5vRo2l1GV4pwSTQhSgJEuNg3X/h0EK0SwM2tF7A63vsuZUUx4i2Hozv0gDHIr56RRQ9+YSFsGRaG+deWf0a3LlOTLNxvBjdib2bE2nh7si0J71pVE0eAVdaSKALYaluXzbOinhiJemuTZlbazof77alYrk0ZvT3pW9zNxleKWUk0IWwNFrDwV9g3X/Rackc83qFESdbcTUqjcGBdXita0Ocy8ncK6WRBLoQluR6pPEJQmeDSaweyH/TRrJsfzl8azowd7g3TWtWMHeFwowk0IWwBIZ02DsXNr6DVop17hMYd8qPcna2vPdUQ3lykAAk0IUo/q6egBXjIHov16p3YFTcYPafcKS/f00mPtaIyo525q5QFBMS6EIUV+mpsP1z2PoxBhtHfnR9k3civKlf1Ynfn/ehpYc8mFncSwJdiOLo4gFYPhauHCXCtRvPXu7HlXgnJnTzZGT7uthalzF3haIYkkAXohgpk54M6yfBzi9JLevCx05vM/ecF+09XfjpSW/qVHYwd4miGJNAF6K4iNxBQMh4uHOR/S69GH6hJzYOlZj5tBc95ZZ9YQIJdCHMLemW8VFwIfNIsanKGzZTWHmhAYMCazOhWyOcy8o15cI0EuhCmNOpv2HlePSti6wv35eXrj5BnWpVWDLEh+a1K5q7OmFhJNCFMIeEWFg7EY78znWHurxgmMqh6w3o1dCKd4e2w8ZKTnqKByeBLkRR0hqOLYXVr6OTbrCo7DNMju1Gu0ZurO/dhPBDeyXMRb5JoAtRVG5dglWvwMnVXHZozL+TJ3BF1eOTp5vcnac83Nw1CosmgS5EYdMa9i+Av/+HIS2Jb+2GMz32UXo3q80vPbyo6GBr7gpFCSGBLkRhijtrnEwrYisRjs0YfmsIqc4ezBvuTceGVc1dnShhJNCFKAyGdNj9FWx6lzTK8In1aL6JbcfQ1nWZ0K0hDvL0IFEI5LdKiIJ2JQxWjIULoRx1aM1zsc/gWLUOfwxpin8duRRRFB4JdCEKSloKbP8Uts4g2dqRKWo8i2+05IVOnrwYVA87aytzVyhKOAl0IQrChVDjZFpXw9jn1InnY/rj5laLv/o3lWd6iiIjgS7Ew0hJhM3vwe45JNlX4c0yE1kZ58tLXT0Z/Ug9rOWaclGEJNCFyK+IrbDiP3A9gh0VejL6cm9qVa/GigG+NK4uR+Wi6Jl0+KCU6q6UOqmUCldKTcyhzQClVJhS6phS6teCLVOIYiTppvFSxB97kpiazgtWU3j26jOM6OzL8rFtJcyF2eR5hK6UsgJmA12AaGCfUmqF1josUxtP4E2grdb6ulJKLrAVJdPJNbDyZXT8FbZUHsjoC91wr+bCsn/74u3mbO7qRClnypBLSyBca30WQCm1COgNhGVqMxKYrbW+DqC1vlrQhQphVgnXYM0bcHQxCRUaMs56PFsu1eaFoHqM61RfrmARxYIpge4GnM+0HA0EZmnTAEAptQOwAqZordcWSIVCmJPWcGQxrHkdnXybLdWfY2REB2pXcWbpUD98a1Uwd4VC3KW01rk3UKof0F1r/VzG8hAgUGs9NlOblUAqMACoCWwFfLTWN7LsaxQwCsDV1dV/0aJF+So6Pj4eR0fHfG1rqaTPRc8u6Rqep7/GJXYfMQ4NeCXpObYl1KRTbWsGNLTFzqrgnyBk7j6bg/T5wQQFBYVqrQOyW2fKEfoFoFam5ZoZr2UWDezRWqcCEUqpU4AnsC9zI631t8C3AAEBAbpjx44mdSCr4OBg8rutpZI+FyGDAfbPh52T0IY0dnu+yrAwfxzL2vHD8KYEFeIcLPI5lw6F1WdTAn0f4KmU8sAY5AOBZ7K0WQY8DfyglHLBOARztgDrFKJoxJ4xXop4bjvJtdrxRspzLDtiS1cvVz7o40NlRztzVyhEjvIMdK11mlJqLLAO4/j491rrY0qpqUCI1npFxrquSqkwIB2YoLWOLczChShQ6Wmwe47xJiErOw41n8aQ/Q1IM8BHfb0YEFBLHtIsij2TbizSWq8GVmd5bVKm7zXwSsaXEJbl8lHjZFoXD5Dm+Rjv6ueYvzMZv1pOfP4vP9xdHMxdoRAmkTtFRemVlgzbPjF+2Vcg6tHZDN1dg6jrd3ipkyfjHq0vt+4LiyKBLkqn8/uMR+UxJ9BNB/BrhTFMWXeJyg6ahSNbEVi3srkrFOKBSaCL0iUlATa9a3z4RPka3O77Ky/vr8qGvRfp3Lgq0/v5yiPhhMWSQBelx9lg4xUsN85Bi+fYV28c45aeIS7hGpN7ejGsjbuc+BQWTQJdlHx3bsDfb8OBn6BSPdKfXcWXZ6oy88dj1KnswNJn28g8LKJEkEAXJduJVbDyFUiIgbbjudJ8PP9ZfII9Eafp08yNqU964yjP9xQlhPwmi5Ip/iqseR2O/QmuPvDMInYk1uKlr0JITEnnk/6+9PWvae4qhShQEuiiZNEaDv8GaycaT4A++jaG1i8xZ9s5Pl2/h7pVHFk0qjn1qzqZu1IhCpwEuig5bpyHlS9D+Hqo2RJ6z+KGgwcv/3yQzSdj6OVbgw/6+OAgQyyihJLfbGH5DAYImQcbpoA2QPePoOVIDl24zZh524m5ncy0J70ZHFhbrmIRJZoEurBs18JhxTiI2gl1g6DnF+gKtfl59zmmrTxOFSc7/hjdWuYtF6WCBLqwTOlpsOtL2PwB2NhD7zng9wwJKen897eDLD94kaCGVfh0gJ/cKCRKDQl0YXkuHTbetn/pEDTqAU98Ak7VCL96m9E/7+dsTDwTujXkhUfqUaaMDLGI0kMCXViO1CTY+jFs/xzKVYYBC8CrNwCrj1zitT8OUc7Wip9HBNKmvot5axXCDCTQhWWI2mM8Kr92CnyfgW7vQblKpBs0M/4+yVfBZ2heuwJzBvlTzdne3NUKYRYS6KJ4S46HjVNh77fgXBMGL4H6nQG4kZjCfxYdZOupGJ5uWZspvbyws7Yyc8FCmI8Euii2KsYdgDnj4OZ5aDkSOk0CO+MNQScu32LUglAu3bzD+0/58ExgbTNXK4T5SaCL4ufOdVj3Fr6Hf4HKnjB8DdRpfXf1ysMXmfDHYZzsrVk0qjX+dSqasVghig8JdFG8hK2A1a9BwjXO1e5HnSGzjZclAukGzcfrTvDNlrP416nIV4OaU7W8jJcL8Q8JdFE83L5iDPLjK6CaDwz6g4iT16mTEeY3ElMYt/AA205fY1BgbSb3bIKttTweTojMJNCFeWkNB3+Fdf+F1DvQaTK0GQdWNnAyGIDjl24x6qcQrtxM5sM+PgxsKePlQmRHAl2Yz/VzsHI8nNkEtVtDry/BxfOeJisOXeSNxYcpX9aaRc+3onltGS8XIicS6KLoGQywby5seAeUgsdnQMAIKPP/Qyhp6QZ+O5nCmogDBNSpyJzBzanqJOPlQuRGAl0UrZhTxsm0zu+Gep2g5+dQ4d4hlOsJxvHy7RGpDG5Vm0k9ZLxcCFNIoIuikZ4KO76ALR+BTTl48mvwHWg8Qs8k7KJxvPzqrWSGe9sy+UkfMxUshOUx6bBHKdVdKXVSKRWulJqYS7u+SimtlAoouBKFxbt4EOYGwaZp0PAxGLsP/J6+L8yXH7xAn692kJau+X10ax6paWOeeoWwUHkeoSulrIDZQBcgGtinlFqhtQ7L0s4JeAnYUxiFCguUesd4RL5jJji4wL9+hsY972uWlm7go7UnmLstghbuFZk9yDheHnzGDDULYcFMGXJpCYRrrc8CKKUWAb2BsCztpgEfARMKtEJhmc7tMk6mFRsOzQZD13eh7P1XqMQlpDBu4X52hMcytHUd3n7CS8bLhcgnUwLdDTifaTkaCMzcQCnVHKiltV6llJJAL82SbxuvXtk313iyc8gyqBeUbdNjF28yakEoMfHJfNyvKQMCahVtrUKUMEprnXsDpfoB3bXWz2UsDwECtdZjM5bLAJuAYVrrSKVUMPCa1jokm32NAkYBuLq6+i9atChfRcfHx+Po6JivbS2VJfS5UmwoDU7NwS45lgtuPYjwGES6ddls2+66mMYPR5NxsFGMa25HXef7Z0m0hD4XNOlz6fAwfQ4KCgrVWmd/nlJrnesX0BpYl2n5TeDNTMvOwDUgMuMrCbgIBOS2X39/f51fmzdvzve2lqpY9zkhVuslo7SeXF7rL1toHbUnx6apael62l/HdJ03Vur+X+3UV28l5di2WPe5kEifS4eH6TMQonPIVVOGXPYBnkopD+ACMBB4JtMfhJvA3cfD5HaELkoYrSFsGayeYJwhscME45e1XbbNM4+XP9u6Dm/38MLGSsbLhSgoeQa61jpNKTUWWAdYAd9rrY8ppaZi/EuxorCLFMXQ7cuw6lU4sRKq+8GQP42TauUg83j59H5N6S/j5UIUOJNuLNJarwZWZ3ltUg5tOz58WaLY0hoO/Azr3oL0ZOgyFVq9CFY5/yotP3iBN5YcpkJZW/54vjW+tSoUXb1ClCJyp6gw3fVI+OslOBsMddpCz5ngUj/H5mnpBj5cc4LvtkfQ0r0Sswc1p4pT9sMxQoiHJ4Eu8mZINz7Tc+NUUFbwxKfgP/yeybSykvFyIYqeBLrI3dUTxhuEovdB/S7GybSca+a6iYyXC2EeEugie2kpsONz2DodbB2hz1zw6X/f/CtZLQmN5q1lR2S8XAgzkEAX97uw3zjF7ZWj4N0Xun8EjlVy3SQpNZ2pK8P4dU8UrepW4sunZbxciKImgS7+X+od2Pw+7JoFjq4wcCE0ejzPzc7HJfLir/s5HH2T0Y/U47WuDbCW8XIhipwEujCK3G48Ko87C82fNV6OWLZCnpsFn7zK+N8Okp6u+WaIP92aVCv8WoUQ2ZJAL+2SbsGGyRDyPVR0h6EroO4jeW5mMGhmbjrNFxtP09DVia8H++Pu4lD49QohciSBXpqdWgcrX4bbl6D1WAj6L9jmHcrXE1IY/9tBtpyKoU9zN9570oeytvdPriWEKFoS6KVRQiysnQhHfocqjWHAAqhp2kOmDp2/wZhf9hNzO5n3n/Lh6Za1UHlc+SKEKBoS6KWJ1nB0Cax53TjU8shEaP8qWNuasKlm3vYIPlp7gqpO9vwxWi5JFKK4kUAvLW5dNE6mdXI11GgOvWeBaxOTNr2ekMJrfxxi44mrdPVy5eN+TalQLu8/AkKIoiWBXtJpDft/hL//B+mpxkfBtRoDZUwb894bEcdLiw4QG5/ClJ5ePNvGXYZYhCimJNBLsrizsOI/ELkN3NtDzy+gcj2TNk03aL4KDufT9aeoXakcS8e0wdvNuZALFkI8DAn0ksiQDru/gk3vgpUN9PjceG15LpNpZXb1dhKv/HaI7eHX6OVbg/ee8sbJ3qZwaxZCPDQJ9JLmSphxMq0LodCgu3FmRGc3kzffePwKbyw5THxyGh/19WFAgFzFIoSlkEAvKdJSYPunsHUG2JeHvvOM87CYGMaJKWm8u+o4v+6JonH18vw60o8Grk6FXLQQoiBJoJcE0aHGo/KrYcYZEbt/BA6VTd780PkbjP/tIJGxCTzfoS6vdG2AnbXcKCSEpZFAt2QpibD5Pdg9BxyrwdO/QcPuJm+elm7gq+AzfLHxNFWc7PjluUDa1HPJe0MhRLEkgW6pIrYaJ9O6Hml8elCXd8De9KtQomITefn3g4Seu04v3xpM6+2Nczk58SmEJZNAtzRJN43XlO//ESp6wLMrwaO9yZsbDJoFuyL5aO1JrK0UXwz0o7ef6SdNhRDFlwS6JTm5xjiZVvwVaPMf6Pgm2JYzefPIawm8vuQweyPieKRBFT7o40ONCmULsWAhRFGSQLcECddoHDYDgrdB1SYw8Fdwa27y5ukGzfydkUxfdwIbqzJM79eUfv415XJEIUoYCfTiTGs48geseYMqSbcg6C1oO96kybT+cSYmntcXHyb03HUebVSV95/yoZqzfeHVLIQwGwn04upmNKx8BU6vA7cAQmo8S8tHhpq8eUqagbnbzjJz42nsrMvw6QBfnmrmJkflQpRgJgW6Uqo78AVgBXyntf4wy/pXgOeANCAG+LfW+lwB11o6GAwQ+gOsnww6Hbp9AIHPk7h1m8m72BcZx1t/HuHUlXi6N6nG1N5NqFpejsqFKOnyDHSllBUwG+gCRAP7lFIrtNZhmZodAAK01olKqReAj4F/FUbBJVrsGeNkWue2g8cjxsm0KnmYvPmNxBQ+XHOCRfvO41ahLPOeDaBTY9dCLFgIUZyYcoTeEgjXWp8FUEotAnoDdwNda705U/vdwOCCLLLES0+D3bNh8/tgZQe9ZkGzwSbftq+1ZtnBC7y78jg37qQyqkNdxnf2pJytjKgJUZqY8n+8G3A+03I0EJhL+xHAmocpqlS5fASWj4VLB6HhE/DEJ1C+usmbH7t4k3f+CmNvRBx+tSrw01M+eNUoX3j1CiGKLaW1zr2BUv2A7lrr5zKWhwCBWuux2bQdDIwFHtFaJ2ezfhQwCsDV1dV/0aJF+So6Pj4eR0fHfG1bXChDKnXO/U7tqCWkWTty2vN5Yqq0yfGoPGufb6dolpxOYcv5NBxtoG8DWzrUtKZMCTrpWRI+5wclfS4dHqbPQUFBoVrr7B8CrLXO9QtoDazLtPwm8GY27ToDx4Gqee1Ta42/v7/Or82bN+d722Ihao/WX7bQenJ5rZeM0johNs9N/ulzalq6/mH7We0zea2u++YqPWXFUX0jIaWQCzYPi/+c80H6XDo8TJ+BEJ1Drpoy5LIP8FRKeQAXgIHAM5kbKKWaAd9gPJK/mo8/OqVDSgJsnAZ7vobybjBoMXh2MWlTrTVbTsXw3qowTl2Jp72nC5N6eOEpU9wKITLkGeha6zSl1FhgHcbLFr/XWh9TSk3F+JdiBTAdcAT+yLjOOUpr3asQ67Y8ZzbDX/+BG1HQ4jnoNNk4b7kJjl64yfSQJMLW7aV2pXJ8O8SfLl6uck25EOIeJl0GobVeDazO8tqkTN93LuC6So47N+Dvt+DAz1CpHgxfA3XamLTp+bhEpq87yYpDF3Gygck9vRgUWAdba9MeJSeEKF3kurbCdHwlrHoVEmKg3cvwyBtgk/dkWHEJKczaFM5PuyOxKqN4MageTcpc4vG2pl+TLoQofSTQC0P8VVg9AcKWgasPPLMIajTLc7PrCSnM3XaWH3dGcic1nQEBtRjfuQHVnO0JDr5c+HULISyaBHpB0hoOLYK1EyE1ER79H7R9Caxyf3DEzcRUvtt+lh92RJKQksYTPtUZ39mT+lXlhKcQwnQS6AXlxnlYOR7CN0DNltB7FlRpmOsmN++k8v32CL7fHsHt5DQe96nGS50a0LCaBLkQ4sFJoD8sgwFC5sGGKcYj9Mc+Nl7FUibnhyzHxifz485I5u+M5FZSGt2auDK+cwMaV5c7PIUQ+SeB/jCunTY+1zNqF9QNMk6mVbFOjs3PxyXy3baz/BZynuQ0A129XBn3qCfebqY/C1QIIXIigZ4f6amw80sI/hBs7KH3HPB7Jsfb9k9cvsU3W86y4tBFyih40s+N5x+pR/2qpet2ZyFE4ZJAf1CXDhkn07p8GBr3hMc/Aaf7p6jVWrMjPJZ528+y+WQM5WytGN7GnRHtPajuLM/xFEIUPAl0U6UmwdaPYfvnUK4yDFgAXr3va3YnJZ2lB6KZvyOS01fjqexgy8udG/BsmzpUKGf6o+OEEOJBSaCbImq38ag89jT4PgPd3oNyle5pcuHGHRbsimTR3vPcvJNKkxrlmdHflx5Nq2Nvk/MJUiGEKCgS6LlJjoeNU2Hvt+BcCwYvgfr/P8uB1ppdZ2L5afc51h0z3vjTrUk1hrf1oIV7RZlrRQhRpCTQcxK+Af56GW6eh5ajoNMksDOexLwWn8yS0GgW7o0iMjYR57I2jOxQl6Gt3XGrIOPjQgjzkEDPKjEO1r0Fh36Fyp7w77VQuxUGg2ZX+DV+3RvF38cuk5quaeFekZc6e/KYtwyrCCHMTwI9s7DlsOo1SIyF9q9Ch9e5cgeWBp9h0b4ozmUcjQ9p5c7TLWvJXORCiGJFAh3g9mVY/Roc/wuqNSVp4B+si63Ckp8Os/10DAYNLT0q8XLnBnT3riZH40KIYql0B7rWcPBXWPcmOjWJ881fZ05yd1Z+d4X45Au4VSjLmI71eaq5G/WqyE1AQojirfQG+vVz8NdLcHYz0U6+TNAj2bWzEg62MTzuU50+zWsS6FGJMmXkShUhhGUofYFuSOf6ljk4bnuPVAO8nzqchdc60aZ+VT7vXpNuTapR1laGVIQQlqfUBPqlm3fYsWsHTULepnHacYLTffmlyngCm/mxo2kNqjnbm7tEIYR4KCU60GNuJ7Pm6CVWH4zCP/on/mO9lOQyZdnYeCoNOj/H3MoO5i5RCCEKTIkL9KjYRNYdu8y6Y5cJjbqOFxHMLPsd9WwiiK/Xg/JPfUYnx6rmLlMIIQqcxQe61poTl29nhPgVjl+6BYBvNTt+r7eWgAu/oMq5wBM/49i4p5mrFUKIwmORgW7QmpDIuLshHhWXiFLgX7sibz3emF4VInHdMgGiw6HZEOg6DcpWNHfZQghRqCwu0Dcev8LLm+9wa90ubKwUbeq5MPqRenT2qkpVmxTY+A5s+g4q1IYhy6BekLlLFkKIImFxge5WsSwNKpZhSJAPQY2qUt7exrji9Hr4azzcugCtxsCjb4OtnPQUQpQeFhfojaqVZ2wzezr6uRlfSIyDtW/C4UXg0hBG/A21Wpq3SCGEMIMypjRSSnVXSp1USoUrpSZms95OKfVbxvo9Sin3Aq80K63h6FKY1QKOLoYOr8PobRLmQohSK88jdKWUFTAb6AJEA/uUUiu01mGZmo0Armut6yulBgIfAf8qjIIBbJNj4bfBcGIlVPeDocuhmndhvZ0QQlgEU4ZcWgLhWuuzAEqpRUBvIHOg9wamZHy/GJillFJaa12AtRqd+puWe8eBSocuU6HVi2BlcSNHQghR4ExJQjfgfKblaCAwpzZa6zSl1E2gMnAtcyOl1ChgFICrqyvBwcEPXHDZxFg8HOoR0egF7qTWgG3bH3gflig+Pj5fPy9LJn0uHaTPBadID2211t8C3wIEBATojh075ms/weWqk99tLVVwcLD0uRSQPpcOhdVnU06KXgBqZVqumfFatm2UUtaAMxBbEAUKIYQwjSmBvg/wVEp5KKVsgYHAiixtVgDPZnzfD9hUKOPnQgghcpTnkEvGmPhYYB1gBXyvtT6mlJoKhGitVwDzgJ+UUuFAHMbQF0IIUYRMGkPXWq8GVmd5bVKm75OA/gVbmhBCiAdh0o1FQgghij8JdCGEKCEk0IUQooSQQBdCiBJCmevqQqVUDHAun5u7kOUu1FJA+lw6SJ9Lh4fpcx2tdZXsVpgt0B+GUipEax1g7jqKkvS5dJA+lw6F1WcZchFCiBJCAl0IIUoISw30b81dgBlIn0sH6XPpUCh9tsgxdCGEEPez1CN0IYQQWRTrQC+WzzItZCb0+RWlVJhS6rBSaqNSqo456ixIefU5U7u+SimtlLL4KyJM6bNSakDGZ31MKfVrUddY0Ez43a6tlNqslDqQ8fv9uDnqLEhKqe+VUleVUkdzWK+UUjMzfiaHlVLNH+oNtdbF8gvjzI5ngLqALXAI8MrSZgzwdcb3A4HfzF13EfQ5CCiX8f0LpaHPGe2cgK3AbiDA3HUXwefsCRwAKmYsVzV33UXQ52+BFzK+9wIizV13AfS7A9AcOJrD+seBNYACWgF7Hub9ivMR+t1nmWqtU4B/nmWaWW/gx4zvFwOdlFKqCGssaHn2WWu9WWudmLG4G+MDRyyZKZ8zwDSMDx9PKsriCokpfR4JzNZaXwfQWl8t4hoLmil91kD5jO+dgYtFWF+h0FpvxTileE56Awu00W6gglKqen7frzgHenbPMnXLqY3WOg3451mmlsqUPmc2AuNfd0uWZ58z/hlaS2u9qigLK0SmfM4NgAZKqR1Kqd1Kqe5FVl3hMKXPU4DBSqlojNN1jyua0szqQf+fz1WRPlNUFByl1GAgAHjE3LUUJqVUGeBTYJiZSylq1hiHXTpi/FfYVqWUj9b6hjmLKmRPA/O11p8opVpjfGiOt9baYO7CLEVxPkIvjc8yNaXPKKU6A28BvbTWyUVUW2HJq89OgDcQrJSKxDjOuMLCT4ya8jlHAyu01qla6wjgFMaAt1Sm9HkE8DuA1noXYI9xzpOSzKT/501VnAO9ND7LNM8+K6WaAd9gDHNLH1eFPPqstb6ptXbRWrtrrd0xnjfopbUOMU+5BcKU3+1lGI/OUUq5YByCOVuENRY0U/ocBXQCUEo1xhjoMUVaZdFbAQzNuNqlFXBTa30p33sz91ngPM4QP47xyOQM8FbGa1Mx/g8Nxg/8DyAc2AvUNXfNRdDnDcAV4GDG1wpz11zYfc7SNhgLv8rFxM9ZYRxqCgOOAAPNXXMR9NkL2IHxCpiDQFdz11wAfV4IXAJSMf6rawQwGhid6XOenfEzOfKwv9typ6gQQpQQxXnIRQghxAOQQBdCiBJCAl0IIUoICXQhhCghJNCFEKKEkEAXQogSQgJdCCFKCAl0IYQoIf4PN0Z5dwT3liMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# some parameter value\n", + "k0 = 1.16\n", + "def u(t):\n", + " return k0/2.0 * t**2\n", + "\n", + "def f(t):\n", + " return k0 * t\n", + "\n", + "model.fix_branch_input(u)\n", + "grid_sampler = tp.samplers.GridSampler(T_int, 500)\n", + "grid_points = grid_sampler.sample_points().as_tensor\n", + "out = model(tp.spaces.Points(grid_points, T)).as_tensor.detach()[0]\n", + "\n", + "grid_p = grid_points\n", + "plt.plot(grid_p, out)\n", + "plt.plot(grid_p, f(grid_p))\n", + "plt.grid()\n", + "plt.legend(['Network output', 'Analytical solution'])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# some parameter value\n", + "k0 = 5.56\n", + "def u(t):\n", + " return torch.sin(k0 * t)\n", + "\n", + "def f(t):\n", + " return k0 * torch.cos(k0 * t)\n", + "\n", + "model.fix_branch_input(u)\n", + "grid_sampler = tp.samplers.GridSampler(T_int, 500)\n", + "grid_points = grid_sampler.sample_points().as_tensor\n", + "out = model(tp.spaces.Points(grid_points, T)).as_tensor.detach()[0]\n", + "\n", + "grid_p = grid_points\n", + "plt.plot(grid_p, out)\n", + "plt.plot(grid_p, f(grid_p))\n", + "plt.grid()\n", + "plt.legend(['Network output', 'Analytical solution'])" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "fb770cb910411e790a99fd848f827dc995ac53be5098d939fbaa56bcec3c9277" + }, + "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.9.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 33442eba1731b7352c6d3bf844aea02f5ce6ab07 Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Wed, 12 Apr 2023 12:20:56 +0200 Subject: [PATCH 16/30] Add example for inverse DeepONet Signed-off-by: Tom Freudenberg --- examples/deeponet/inverse_ode.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/deeponet/inverse_ode.ipynb b/examples/deeponet/inverse_ode.ipynb index a92fb0fd..1ecdd047 100644 --- a/examples/deeponet/inverse_ode.ipynb +++ b/examples/deeponet/inverse_ode.ipynb @@ -12,10 +12,10 @@ " \\partial_t u(t) &= f(t), \\text{ in } [0, 1] \\\\\n", " u(0) &= 0\n", "\\end{align*}\n", - "for different functions, $f$. (Learning the differential operator)\n", + "for different functions, $f$. Instead of learning the forward (intergal) operator $S:f \\to u$, we aim here to learn the \"inverse\" (differential) operator ${S^{-1}:u \\to f}$. \n", "\n", - "For a non physics DeepONet one needs a data pair of input data and expected solution, for the training of the inverse operator.\n", - "The training would then consist of a fitting procedure.\n", + "For a DeepONet one needs a data pair of input data and expected solution, for the training of the inverse operator.\n", + "The training would then consist of a fitting procedure. Where we plug our training data of $u$ into the branch net and the DeepONet should return the corresponding rhs $f$, at the given trunk input. \n", "\n", "If we want to include physics into the training's loss, one generally needs some derivatives of the solution (which is only given by discrete values). To compute them, one can either apply some finite difference scheme or use one additional DeepONet to first interpolate the data and then train a second network for the inverse operator using the first DeepONet and a physics loss.\n", "\n", From 7ba015acdf62acc86944d7a80e692f192aec5e12 Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Wed, 17 May 2023 11:56:12 +0200 Subject: [PATCH 17/30] Fix bug in partial operator Signed-off-by: Tom Freudenberg --- src/torchphysics/utils/differentialoperators.py | 4 ++-- tests/test_differentialoperators.py | 12 ++++++++++++ 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/src/torchphysics/utils/differentialoperators.py b/src/torchphysics/utils/differentialoperators.py index 237e7d97..1b3977b7 100644 --- a/src/torchphysics/utils/differentialoperators.py +++ b/src/torchphysics/utils/differentialoperators.py @@ -304,11 +304,11 @@ def partial(model_out, *derivative_variables): ''' du = model_out for inp in derivative_variables: + if du.grad_fn is None: + return torch.zeros_like(inp) du = torch.autograd.grad(du.sum(), inp, create_graph=True)[0] - if du.grad_fn is None: - return torch.zeros_like(inp) return du diff --git a/tests/test_differentialoperators.py b/tests/test_differentialoperators.py index 15fc9031..02ca5258 100644 --- a/tests/test_differentialoperators.py +++ b/tests/test_differentialoperators.py @@ -659,6 +659,18 @@ def test_partial_repeated_gives_0(): assert np.allclose(d[0], [[0], [0]]) +def test_partial_repeated_gives_0_2(): + x = torch.tensor([[1.0], [2.0]], requires_grad=True) + y = torch.tensor([[1.0], [3.0]], requires_grad=True) + t = torch.tensor([[2.0], [0.0]], requires_grad=True) + output = part_function(x, y, t) + p = partial(output, x, x, x, x, y) + assert p.shape == (2, 1) + d = p.detach().numpy() + assert np.allclose(d[0], [[0], [0]]) + + + # Test convective def convec_function(x): out = torch.zeros((len(x), 3)) From 931c644e7a8da0c068d63c029f8d23c6cfa4baaf Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Mon, 22 May 2023 16:32:43 +0200 Subject: [PATCH 18/30] update docs Signed-off-by: Tom Freudenberg --- CHANGELOG.rst | 5 +++ docs/index.rst | 2 +- docs/tutorial/applied_tutorial_start.rst | 45 ++++++++++++++++++++++ docs/tutorial/main_page.rst | 48 ++++++++++++++++++++++++ 4 files changed, 99 insertions(+), 1 deletion(-) create mode 100644 docs/tutorial/applied_tutorial_start.rst create mode 100644 docs/tutorial/main_page.rst diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 162c44ca..33beb4eb 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -7,3 +7,8 @@ All notable changes to this project will be documented in this file. Version 1.0 =========== First official release of TorchPhysics on PyPI. + +Version 1.1.0 +============= + - Updated documentation. + - Simplyfied creation/definition of DeepONets. \ No newline at end of file diff --git a/docs/index.rst b/docs/index.rst index 8407ba40..cd697c1c 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -34,7 +34,7 @@ can be found. :maxdepth: 2 Overview - Tutorial + Tutorial Examples diff --git a/docs/tutorial/applied_tutorial_start.rst b/docs/tutorial/applied_tutorial_start.rst new file mode 100644 index 00000000..e5cdc613 --- /dev/null +++ b/docs/tutorial/applied_tutorial_start.rst @@ -0,0 +1,45 @@ +============================== +Applied TorchPhysics Tutorials +============================== +Here, we explain the library of TorchPhysics along the implementation of different +examples. + +To start, we consider a heat equation problem of the form + +.. math:: + \begin{align} + \partial_t u(x,t) &= \Delta_x u(x,t) \text{ on } \Omega\times I, \\ + u(x, t) &= u_0 \text{ on } \Omega\times \{0\},\\ + u(x,t) &= h(t) \text{ at } \partial\Omega_{heater}\times I, \\ + \nabla_x u(x, t) \cdot n(x) &= 0 \text{ at } (\partial \Omega \setminus \partial\Omega_{heater}) \times I, + \end{align} + + +that we will solve with PINNs. This example is a nice starting point for a new user and can +be found here_. The notebook gives a lot of information about TorchPhysics and even repeats the +basic ideas of PINNs. + +.. _here : https://github.com/boschresearch/torchphysics/blob/main/examples/tutorial/Introduction_Tutorial_PINNs.ipynb + +A next step would be to make the problem more complicated, such that not a single solution +should be found, but a whole family of solutions for different functions :math:`h`. +As long as the different :math:`h` can be defined through some parameters, the solution operator +can still be learned through PINNs. This is explained in this notebook_, which is really similar to +previous one and highlights the small aspects that have to be changed. + +.. _notebook : https://github.com/boschresearch/torchphysics/blob/main/examples/tutorial/Tutorial_PINNs_Parameter_Dependency.ipynb + +For more complex :math:`h` functions, we end up at the DeepONet. DeepONets can also be learned +physics informed, which is demonstrated in this tutorial_. + +.. _tutorial : https://github.com/boschresearch/torchphysics/blob/main/examples/tutorial/Introduction_Tutorial_DeepONet.ipynb + +Similar examples, with a description of each step, can be found in the two notebooks `PINNs for Poisson`_ +and `DRM for Poisson`_. The second notebook +also uses the Deep Ritz Method instead of PINNs. + +More applications can be found on the `example page`_. + +.. _`PINNs for Poisson`: https://github.com/boschresearch/torchphysics/blob/main/examples/tutorial/solve_pde.ipynb +.. _`DRM for Poisson`: https://github.com/boschresearch/torchphysics/blob/main/examples/tutorial/solve_pde_drm.ipynb +.. _`example page`: https://torchphysics.readthedocs.io/en/latest/examples.html \ No newline at end of file diff --git a/docs/tutorial/main_page.rst b/docs/tutorial/main_page.rst new file mode 100644 index 00000000..8e314648 --- /dev/null +++ b/docs/tutorial/main_page.rst @@ -0,0 +1,48 @@ +========================= +The TorchPhysics Tutorial +========================= +Here one can find all important information and knowledge to get started with the +software library TorchPhysics. + +In order to make it as easy and user-friendly as possible for all users, +both complete novices and professionals in Machine Learning and PDEs, to get started, the tutorial +starts with some basics regarding differential equations and neural networks. For more +experienced users, these points can be skipped. + +Afterward, we give a rough overview of different Deep Learning approaches for solving +differential equations, with a focus on PINNs and DeepONet. + +The main and final topic is the use of TorchPhysics. Here we split the tutorial into two parts. +The first part, guides you along some implementations of different small examples, while showing +all the important aspects and steps to solve a differential equation in TorchPhysics. This tutorial +series is aimed at an audience which is more interested on the direct utilization of the library +and for getting a fast and small overview of the possibilities. + +To get a deeper understanding of the library, we show in the second part how the library is +internally structured. This series is more aimed for users who plan to add or change functionalities. + + +Basics of Deep Learning and Differential Equations +===================================================== +Will be added in the future. + + +Overview of Deep Learning Methods for Differential Equations +============================================================ +Will be added in the future. + + +Usage of TorchPhysics +===================== +Like mentioned at the beginning, here we explain the aspects of TorchPhysics in more +detail. We split the tutorial into two categories: + +1) A more applied tutorial to learn TorchPhysics by implementing some examples. + All basics features will be explained. The start can be found here_. + +2) A more in depth tutorial that focuses more on the library architecture. This + tutorial begins on this page_. + + +.. _here : applied_tutorial_start.html +.. _page : tutorial_start.html \ No newline at end of file From e85d0770866cb3596069c5b42d32bb409e29441f Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Mon, 22 May 2023 16:33:29 +0200 Subject: [PATCH 19/30] simplify DeepONet creation Signed-off-by: Tom Freudenberg --- examples/deeponet/inverse_ode.ipynb | 27 ++-- examples/deeponet/ode.ipynb | 57 ++++---- examples/deeponet/oscillator.ipynb | 35 +++-- .../models/deeponet/branchnets.py | 83 ++++++----- src/torchphysics/models/deeponet/deeponet.py | 25 +++- src/torchphysics/models/deeponet/trunknets.py | 63 +++++---- .../utils/data/deeponet_dataloader.py | 2 +- tests/tests_models/test_deep_o_net.py | 129 +++++++++--------- 8 files changed, 213 insertions(+), 208 deletions(-) diff --git a/examples/deeponet/inverse_ode.ipynb b/examples/deeponet/inverse_ode.ipynb index 1ecdd047..86e32b34 100644 --- a/examples/deeponet/inverse_ode.ipynb +++ b/examples/deeponet/inverse_ode.ipynb @@ -88,11 +88,10 @@ "source": [ "# Model\n", "dis_sampler = tp.samplers.GridSampler(T_int, 50).make_static()\n", - "trunk_net = tp.models.FCTrunkNet(T, F, hidden=(30, 30), output_neurons=50)\n", - "branch_net = tp.models.FCBranchNet(Fn_space, F, output_neurons=50, \n", - " hidden=(50, 50), \n", + "trunk_net = tp.models.FCTrunkNet(T, hidden=(30, 30))\n", + "branch_net = tp.models.FCBranchNet(Fn_space, hidden=(50, 50), \n", " discretization_sampler=dis_sampler)\n", - "model = tp.models.DeepONet(trunk_net, branch_net)" + "model = tp.models.DeepONet(trunk_net, branch_net, output_space=F, output_neurons=50)" ] }, { @@ -219,16 +218,16 @@ "0 Non-trainable params\n", "10.2 K Total params\n", "0.041 Total estimated model params size (MB)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 24 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " warnings.warn(*args, **kwargs)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 24 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " warnings.warn(*args, **kwargs)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c321590cbc654d09a34db65f5a80fb5d", + "model_id": "6df74512dbe940048c789d28e5b70794", "version_major": 2, "version_minor": 0 }, @@ -242,7 +241,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "88c53926d316487e836634cc0892f272", + "model_id": "bdccd39ed3154e2c8fc1240e65c0b356", "version_major": 2, "version_minor": 0 }, @@ -297,7 +296,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f2c1d0a05b964c498eab96518f8f5e21", + "model_id": "8ec664fa457e48b195d1f8f19aee774c", "version_major": 2, "version_minor": 0 }, @@ -311,7 +310,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2ad83fe996454ae6927d9b01c96070de", + "model_id": "113e3bc6b95c4f4798317b9d63eed528", "version_major": 2, "version_minor": 0 }, @@ -347,7 +346,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -356,7 +355,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -398,7 +397,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 10, @@ -407,7 +406,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/examples/deeponet/ode.ipynb b/examples/deeponet/ode.ipynb index bae8d162..49e5f684 100644 --- a/examples/deeponet/ode.ipynb +++ b/examples/deeponet/ode.ipynb @@ -28,7 +28,7 @@ "outputs": [], "source": [ "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\"\n", "import torch\n", "import torchphysics as tp\n", "import pytorch_lightning as pl" @@ -83,11 +83,10 @@ "source": [ "# Model\n", "dis_sampler = tp.samplers.GridSampler(T_int, 50).make_static()\n", - "trunk_net = tp.models.FCTrunkNet(T, U, hidden=(30, 30), output_neurons=50)\n", - "branch_net = tp.models.FCBranchNet(Fn_space, U, output_neurons=50, \n", - " hidden=(50, 50), \n", + "trunk_net = tp.models.FCTrunkNet(T, hidden=(30, 30))\n", + "branch_net = tp.models.FCBranchNet(Fn_space, hidden=(50, 50), \n", " discretization_sampler=dis_sampler)\n", - "model = tp.models.DeepONet(trunk_net, branch_net)" + "model = tp.models.DeepONet(trunk_net, branch_net, U, output_neurons=50)" ] }, { @@ -141,7 +140,7 @@ "text": [ "GPU available: True, used: True\n", "TPU available: False, using: 0 TPU cores\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [1]\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", "\n", " | Name | Type | Params\n", "------------------------------------------------\n", @@ -152,16 +151,16 @@ "0 Non-trainable params\n", "10.2 K Total params\n", "0.041 Total estimated model params size (MB)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 24 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " warnings.warn(*args, **kwargs)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 24 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " warnings.warn(*args, **kwargs)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f0e44390260e4d55acfa5e867c2dd001", + "model_id": "f2349bee03f34d7f8758d4bb2f4eaedd", "version_major": 2, "version_minor": 0 }, @@ -175,7 +174,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "412da0e2778f4c5d9586c39ca9ad83cd", + "model_id": "e4d434a1dc5742bebbe7109a4abcead2", "version_major": 2, "version_minor": 0 }, @@ -205,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -214,7 +213,7 @@ "text": [ "GPU available: True, used: True\n", "TPU available: False, using: 0 TPU cores\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [1]\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", "\n", " | Name | Type | Params\n", "------------------------------------------------\n", @@ -230,7 +229,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f76819cd01c84b3f94d5f07e112dfa68", + "model_id": "2b2610116f574ffba78d4f60b66d25bb", "version_major": 2, "version_minor": 0 }, @@ -241,20 +240,10 @@ "metadata": {}, "output_type": "display_data" }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n" - ] - }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8b173daf653649f5a0181609dde5e076", + "model_id": "caf835a0baeb42b9b684c43b8eba01ce", "version_major": 2, "version_minor": 0 }, @@ -268,7 +257,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8cef152b3e804c89b6d7272bb6edb96f", + "model_id": "ae55eac3287f4806b3476dea0284c6d6", "version_major": 2, "version_minor": 0 }, @@ -306,22 +295,22 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 15, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -356,22 +345,22 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 14, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -422,7 +411,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.9.15" }, "orig_nbformat": 4 }, diff --git a/examples/deeponet/oscillator.ipynb b/examples/deeponet/oscillator.ipynb index 962fdc7f..9eba7475 100644 --- a/examples/deeponet/oscillator.ipynb +++ b/examples/deeponet/oscillator.ipynb @@ -94,12 +94,11 @@ "# Model\n", "dis_sampler = (tp.samplers.GridSampler(A_t.boundary_left, n_points = 1)\n", " + tp.samplers.GridSampler(A_t, n_points = 800)).make_static()\n", - "trunk_net = tp.models.FCTrunkNet(T, U, hidden=(50, 50), output_neurons=80,\n", + "trunk_net = tp.models.FCTrunkNet(T, hidden=(50, 50),\n", " xavier_gains=[3/5, 3/5, 0.0])\n", - "branch_net = tp.models.ConvBranchNet1D(Fn_space, U, output_neurons=80, \n", - " convolutional_network=ConvolutionLayers(),\n", + "branch_net = tp.models.ConvBranchNet1D(Fn_space, convolutional_network=ConvolutionLayers(),\n", " hidden=(600, 500, 250), discretization_sampler=dis_sampler)\n", - "model = tp.models.DeepONet(trunk_net, branch_net)" + "model = tp.models.DeepONet(trunk_net, branch_net, U, output_neurons=80)" ] }, { @@ -182,16 +181,16 @@ "0 Non-trainable params\n", "933 K Total params\n", "3.735 Total estimated model params size (MB)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 24 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " warnings.warn(*args, **kwargs)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 24 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " warnings.warn(*args, **kwargs)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8933d98cf8b742f7aa925ec87bbe3e5c", + "model_id": "59015f1c25d44d81b08ccf672fc9ad54", "version_major": 2, "version_minor": 0 }, @@ -205,7 +204,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "76e8714ecf2a456f858722aa9e41d27b", + "model_id": "460abca5f9a34718afe42d3137125006", "version_major": 2, "version_minor": 0 }, @@ -258,7 +257,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "987631479e3d4fcc8175d4e507ba03b8", + "model_id": "17ef34adef49498bb58127bc9d8151b1", "version_major": 2, "version_minor": 0 }, @@ -272,7 +271,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5a2e9b4224c345aaa6fb67e6163d6aed", + "model_id": "d3ed94b3061a4eba88de1a102194739c", "version_major": 2, "version_minor": 0 }, @@ -286,7 +285,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "72aa65012189496c8404ee3fffbaa243", + "model_id": "df5cb8df26d242d98acf98368734a9de", "version_major": 2, "version_minor": 0 }, @@ -329,7 +328,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -338,7 +337,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -380,22 +379,22 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD5CAYAAAAuneICAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABH00lEQVR4nO3dd3hUVfrA8e87k94bCSVAQie00EKREqy4IuDaQAV1VVZd7KK4rmVdd1dXf7prWbtiBwVFVlEUISIgHUSK1FBCJ4UU0nN+f9whhhDIJEwySeb9PM88uXPuvee+J4F5595z7zlijEEppZTnsbk7AKWUUu6hCUAppTyUJgCllPJQmgCUUspDaQJQSikPpQlAKaU8lJczG4nISOA/gB140xjzVKX19wI3AyXAEeAPxpjdjnXXA39xbPqkMeZdR3lfYBrgD8wF7jLV3JMaFRVl4uLinGpYZXl5eQQGBtZq38ZK2+wZtM2e4WzavHr16qPGmGanrDDGnPGF9aG/A2gH+AA/AwmVthkBBDiWbwNmOJYjgJ2On+GO5XDHuhXAQECAr4GLq4ulb9++prYWLlxY630bK22zZ9A2e4azaTOwylTxmerMJaAkYLsxZqcxpgiYDoyplEQWGmOOO94uA2IdyxcB3xljMowxmcB3wEgRaQGEGGOWOYJ7DxjrRCxKKaVcxJlLQK2AvRXepwEDzrD9TVjf6E+3byvHK62K8lOIyCRgEkBMTAwpKSlOhHyq3NzcWu/bWGmbPYO22TPURZud6gNwlohcB/QDhruqTmPM68DrAP369TPJycm1qiclJYXa7ttYaZs9g7bZM9RFm51JAPuA1hXexzrKTiIi5wMPA8ONMYUV9k2utG+Kozy2UvkpdSql6k9xcTFpaWkUFBS4O5RqhYaGsnnzZneHUa+cabOfnx+xsbF4e3s7VaczCWAl0FFE4rE+pMcB11TcQER6A68BI40xhyusmgf8Q0TCHe8vBB4yxmSISLaIDASWAxOBF52KWClVJ9LS0ggODiYuLg4RcXc4Z5STk0NwcLC7w6hX1bXZGEN6ejppaWnEx8c7VWe1ncDGmBJgMtaH+WbgE2PMRhF5QkRGOzZ7BggCPhWRdSIyx7FvBvA3rCSyEnjCUQZwO/AmsB3rLqMT/QZKKTcoKCggMjKywX/4q6qJCJGRkTU6g3OqD8AYMxfrXv2KZY9WWD7/DPu+DbxdRfkqoLvTkSql6px++DduNf37ubQTWDkYA/tWw97lUFIIEe2gXTL4h7k7MqWUKqdDQbjawQ3wxrnw5nkw78/w/V/h0+vh+W7w3WNQdLz6OpTyUCLCfffdV/7+2Wef5fHHHz/jPikpKSxdutTlsUybNo3Jkye7tM6srCz++9//nlUds2fPZtOmTS6JRxOAK22dZ334H0uDUf+G+7fDwwfhD/Og88Ww5N/w2lA4ssXdkSrVIPn6+vLZZ59x9OhRp/epiwRQUlLi0vpO0ATQVO1ZBtOvheiucPtP0O9GCGoG3v7QZiBc/iZMnAMF2fDWhbB3hbsjVqrB8fLyYtKkSTz//POnrDty5AiXX345/fv3Z/jw4SxZsoRdu3bx6quv8vzzz5OYmMgPP/xAfHw8xhiysrKw2+0sWrQIgGHDhrFt2zYyMjIYO3YsPXv2ZODAgaxfvx6Axx9/nAkTJnDOOecwYcKEk4791VdfMWjQoFMS05nqevbZZ8u36969O7t27WLq1Kns2LGDxMREpkyZQkpKCsOGDeOSSy6hc+fO3HrrrZSVlQEQFBRUvv/MmTO59dZbWbp0KXPmzGHKlCkkJiayY8eOs/t9n9XeypJ7BD69AUJjYeJs8A+vert2w+Hm7+D938MHV8CNX0HzHvUZqVJO+ev/NrJpf7ZL60xoGcJjl3ardrs//elP9OzZkwceeOCk8rvuuot77rmHIUOGsGnTJi6//HI2b97MrbfeSlBQEPfffz8AnTt3ZtOmTaSmptKnTx9+/PFHBgwYwN69e+nYsSN33HEHvXv3Zvbs2SxYsICJEyeybt06ADZt2sTixYvx9/dn2rRpAHz++ec899xzzJ07l/Dwk/9vP/bYY6etqypPPfUUGzZsKN8mJSWFFStWsGnTJtq2bcvIkSP57LPPuOKKK6rcf/DgwYwePZpRo0addpua0ATgCt8+DMfT4ZYFp//wPyE8DiZ+AW9fZCWCP/4AIS3rJUylGoOQkBAmTpzICy+8gL+/f3n5/Pnzyy99lJWVkZ2dTW5u7in7Dx06lEWLFpGamspDDz3EG2+8wfDhw+nfvz8AixcvZtasWQCce+65pKenk51tJbvRo0efdMwFCxawatUqvv32W0JCQk451pnqclZSUhLt2rUDYPz48SxevNglH+7O0ARwtnYtgfUzYNgU57/Nh7WG62bBm+fDJ9fDDV+Bl0/dxqlUDTjzTb0u3X333fTp04cbb7yxvKysrIxly5bh5+d3xoeihg0bxiuvvML+/ft54okneOaZZ0hJSWHo0KHVHrfycMvt27dn586dbN26lX79+jkdv5eXV/mlHOCM9+ZXvnXzxPuK5XX1dLb2AZwNY2D+YxASC0Purdm+0V1hzEuQtgK+e7T67ZXyIBEREVx11VW89dZb5WUXXnghL77424ABJy6jBAcHk5OTU16elJTE0qVLsdls+Pn5kZiYyGuvvcawYcMA6wzhww8/BKxLMFFRUVV+uwdo27Yts2bNYuLEiWzcuPGU9aerKy4ujjVr1gCwZs0aUlNTq4wVYMWKFaSmplJWVsaMGTMYMmQIYA1+uXnzZsrKyvj888/Lt6+qjtrSBHA2Un+AtJUw9B7wCaj5/t0ug6Q/wvJXIHWR6+NTqhG77777Tup0feGFF1i1ahU9e/akf//+vPrqqwBceumlfP755yQmJvLjjz/i6+tL69atGThwIGB9SOfk5NCjh3WG/vjjj7N69Wp69uzJ1KlTeffdd88YR5cuXfjwww+58sorT+l0PV1dl19+ORkZGXTr1o2XXnqJTp06ARAZGck555xD9+7dmTJlCgD9+/dn8uTJdO3alfj4eC677DLA6i8YNWoUgwcPpkWLFuXHHDduHM888wy9e/c+607gaieEaUivBjchzLRRxjzTyZii/NrXUZhnzH96G/N8d2MKsl0Xm9FJMzyFq9q8adMml9RTH7KzXft/xV0WLlxoLrnkEqe2dbbNVf0dOYsJYVRVjm63vrUn3QLefrWvxycAxr4CWXth/uMuC08ppaqjCaC21kwDmxf0nlDtptVqMwAG3Aor34L9a8++PqVUo5CcnMyXX37ptuNrAqiNkiJY95H1dG9wjGvqHPEQBEbB3ClQ4e4BpZSqK5oAamPH99Z9/6749n+CXyhc8ITVqfzzx66rVymlTkMTQG1snG19YLcb4dp6e46D2CSrL6Dw1AdclFLKlTQB1FRJIWz5GrqMcv3DWzYbXPQPyDsMy85uwCillKqOUwlAREaKyBYR2S4iU6tYP0xE1ohIiYhcUaF8hGOGsBOvAhEZ61g3TURSK6xLdFWj6tTOFCg8Bglj6qb+1v2t5LLkBchzfkREpZoCu91OYmJi+eupp5464/Z1MWTzmcTFxVU7Uum0adPYv39/+fubb77ZZaN3ulq1Q0GIiB14GbgASANWisgcY0zFFu0BbgDur7ivMWYhkOioJwJr+sdvK2wyxRgz8yzir3+/fgU+wdYEL3XlvEdhy0D48f9g5D/r7jhKNTD+/v5nHEztbJWUlODlVbcj4EybNo3u3bvTsqU1xtebb75Zp8c7G86cASQB240xO40xRcB04KSvv8aYXcaY9cCZbl+5AvjaGNN4Z0QxBrZ/b43q6eVbd8dp1hkSr4WVb0Lm7ro7jlKNRMVv3qtWreJ3v/vdKdtUHC66f//+LFmyBDjzMM8HDhxg2LBhJCYm0r17d3788UcAPv74Y3r06EH37t158MEHTznWrl276N79txltT0xcM3PmTFatWsW1115LYmIi+fn5JCcns2rVqjPWGxQUxMMPP0yvXr0YOHAghw4dOsvfmHOcSYWtgL0V3qcBA2pxrHHAc5XK/i4ijwLfA1ONMYWVdxKRScAksMbGSElJqcWhITc3t9b7nhCQt5ek7DS2NB/NgTPUVVhq2JJRyoE8gwDNA4XOEXZ87c7P1+nrm8yAsukcmnEvW7rcUat4XdHmxkbbXHuhoaHlY8z4LnwM2+FTx745G2XR3Sgc8dczbpOfn0/Pnj3L3997771cfvnlGGPIzc3F19eXvLw8jDHk5ORQUFBAUVEROTk53H777fzxj39k0KBB7N27l8suu4xVq1ZRWFjIhg0bmDdvHv7+/ieNo/POO++QnJzMlClTKC0t5fjx42zdupUHHniARYsWERYWxtixY/n4448ZNWpUeRy5ubmUlZWV11VYWEhhYSEXXXQRvXv35sknn6RPnz6UlJRQWlpKXl7eGevNy8ujV69eTJ06lUceeYSXXnrplOGwS0tLnRoDqKCgwOl/D/UyGqiItAB6APMqFD8EHAR8gNeBB4EnKu9rjHndsZ5+/fqZ5OTkWsWQkpJCbfct99PLAHT+3W10DmtzyuqS0jLeWpzKK0t2kHW8+KR1/t52ru7fmtuT2xMd4uSTw2UraLHqLVqMex6qOF51XNLmRkbbXHubN2/+bYRNbx+wu/jjwdsHn9OM4HmCv79/+aQqFYkIQUFBBAcHExgYiIgQHByMn58fPj4+BAcH88MPP7Bt27byfXJzcxERfH19GTt2LNHR0afUO2TIEP7whz9gs9kYO3YsiYmJfPHFF4wYMYL4+HgAJk6cyMqVKxk/fnx5HAA2m6389+Xr60txcTHBwcHY7XYCAwPL1514v3nz5tPW6+Pjw5VXXomIMGjQIL777rtTRjs90wioFfn5+dG7d+9qtwPnEsA+oHWF97GOspq4CvjcGFP+qWiMOeBYLBSRd6jUf9Agbf8eojpV+WGcU1DMLe+tYtnODEZ0bsb1g+PoFRtGmTFsPpDD7HX7eH/ZbmatSePxS7vx+z6tThkG9hTn3AWr34HFz8OoU2dIUqrOXHzmztf6VnF45dMNjVxxuOjKKg/zfMKwYcNYtGgRX331FTfccAP33nsvoaGhNYrnTDE5y9vbu/zzwG6319mUlJU50wewEugoIvEi4oN1KWdODY8zHjjp6SbHWQFitXossKGGddavkiLYvbTKe//zi0qZ8NYKVu3K5JkrevL2Df1J7hxNeKAPkUG+DOkYxbNX9mL+vcPp0jyY+z79mYdnb6C4tJonfkNbQe/rYM371jzDSnmouLg4Vq9eDVA+AUtlpxsu+kx2795NTEwMt9xyCzfffDNr1qwhKSmJH374gaNHj1JaWsrHH3/M8OHDT9ovJiaGw4cPk56eTmFh4UnDOZxuuGZn6q1v1SYAY0wJMBnr8s1m4BNjzEYReUJERgOISH8RSQOuBF4TkfKLhyISh3UG8UOlqj8UkV+AX4Ao4EkXtKfuHFwPJfnQdvBJxcYYpn62np/Tsnjpmj5c2a/1ab/Zx0cFMn3SIG5Lbs9Hy/dw07urKCguPfNxh9wDGFjyHxc1RKmGKz8//6TbQKdOte46f+yxx7jrrrvo168fdru9yn0rDhedkJBQPlz0maSkpNCrVy969+7NjBkzuOuuu2jRogVPPfUUI0aMoFevXvTt25cxY06+7dvb25tHH32UpKQkLrjgArp06VK+7oYbbuDWW28t7wQ+wZl6611VQ4Q21Jdbh4Ne/B9jHgsxJvvgScUzV+01bR/80rwwf2uNqvt4+W4TN/VLc92by0x+UcmZN/5isjFPNDPm2P4aHUOHRvYMOhy0Z9DhoN1pzzKIaHfS4G8ZeUU8+dUm+rYN508jOtSounFJbXj68p4s3n6UP324hpIzXQ4aci+UlcBPL9U2eqWUOoUmAGeUlcGen6DNyZd//jN/K9kFJfz9su7YbM7f4nnCVf1a88Tobnz/62Ge/Grz6TeMiIfuv4fV0yA/q8bHUUqpqmgCcEb6NsjPgDYDy4sOHMvn4xV7ubJvLF2aVz2fqDMmDIrj5iHxTFu6i2lLUk+/4eA7oSgXVr1d62MpVR3raoFqrGr699ME4Iw9P1k/2wwqL3olZQdlxtT40k9VHvpdVy5IiOFvX21m+c70qjdq0RPanwvLX7UGpFPKxfz8/EhPT9ck0EgZY0hPT6/yNtjTqZcHwRq9fWvALwwi2wNw7Hgxn6zay+V9YmkdUYvJ4Cux24TnrurF6JeWcMfHa/nqzqE0C65iqInBd8L7Y2H9DOgz8ayPq1RFsbGxpKWlceTIEXeHUq2CgoIafdA1Bc602c/Pj9jYWKfr1ATgjP1roWUiOG7vnLkmjYLiMq4fHOeyQwT7efPfa/sw9uUl3DV9Le/fNAB75X6FdsnQvKc1Umjiddbw0Uq5iLe3d/lTqg1dSkqK00+7NhV10Wb9BKlOcQEc3gwtrV+8MYYPl+2mT5swElrW/tp/Vbq2COFvY7qzdEc6Ly3YfuoGItbTwenbYOs3Lj22UsrzaAKozuGNUFZcngBWpGaw82ge1w5oWyeHu6p/a8YktuSFBdtYn5Z16gYJY62hKPTBMKXUWdIEUJ39a62fLRIBmPPzfvy97Vzco3mdHfKJ0d1pFuTLPTPWnfqksN0LBk2Gvctgz/I6i0Ep1fRpAqjO/nXgHwFhbSgpLePrDQc5r2s0AT51130SGuDNs1f2YseRPJ76+tdTN+h9nTUnsU4bqZQ6C5oAqrN/XXkH8NId6WTkFXFpr5Z1ftghHaO4YXAc05buYsn2SlPQ+QRC3xtg8xzI2lPnsSilmiZNAGdSUgRHNkOLXgB8veEAQb5eDO/UrF4O/+DILrSLCuTBWes5XlRpeNj+twACK96ol1iUUk2PJoAzSd9mjcET0x1jDAt/PcKwTlH4eVc9GqGr+fvYeerynqRl5vPct1tPXhnWGhJGw5p3oSivXuJRSjUtmgDO5JBj3vvorvx6MIeD2QUkdzp1VqG6lBQfwbUD2vD2klR+3pt18sqBt0PBMfj54yr3VUqpM9EEcCaHN4HNCyI7krLFejpyeOf6ufxT0dSLuxAd7MeDs9ZTVFJh1NDY/tCqLyx71RqwTimlasCpBCAiI0Vki4hsF5GpVawfJiJrRKRERK6otK5URNY5XnMqlMeLyHJHnTMcs401LIc3QWRH8PIhZcthElqEEOPsfL4uFOznzZNju/PrwRxeX7TjtxUi1llA+jbY8X29x6WUatyqTQAiYgdeBi4GEoDxIpJQabM9wA3AR1VUkW+MSXS8Rlcofxp43hjTAcgEbqpF/HXr8CaISSCnoJjVuzNJdsO3/xPOT4hhVM8WvPD9drYfzv1tRcIYCG6ht4QqpWrMmTOAJGC7MWanMaYImA6cNI+ZMWaXMWY94NR1CMc8wOcCMx1F72LNC9xwFOZYt1hGd2XVrkxKygxDOkS5NaTHLu2Gn7eNR7/Y8NuIjXZv6H8z7FhgDVmhlFJOcuZpplbA3grv04ABNTiGn4isAkqAp4wxs4FIIMtY8w2fqLNVVTuLyCRgElgTMaekpNTg0L/Jzc2t0b4hx7bQB/jlcBkzN6/DLpCz+xdS0mo+8YsrjW1n471N6Tz98fcMbGn9+byLOjHQ5sOhzx9ja+fby7etaZubAm2zZ9A2u0Z9jAba1hizT0TaAQscE8Efc3ZnY8zrwOsA/fr1M8nJybUKIiUlhRrtu3o3rIUe517FwRkH6NXacNF559Tq2K40tMzw83+XMCu1gNt/fw4hft7WioLxtFw/g5YTXoWACKAWbW4CtM2eQdvsGs5cAtoHtK7wPtZR5hRjzD7Hz51ACtAbSAfCROREAqpRnfXi6Fbw8qcgKJb1aVkkxUe6OyLAmjvgybE9OJpbePKzAQNvg5ICWP2O+4JTSjUqziSAlUBHx107PsA4YE41+wAgIuEi4utYjgLOATY5ZqlfCJy4Y+h64IuaBl+njm6DyPas3ZtNcalhQHyEuyMq1yM2lAkD2/LeT7vYsM9xMhXdFdqNsJ4MLi12b4BKqUah2gTguE4/GZgHbAY+McZsFJEnRGQ0gIj0F5E04ErgNRHZ6Ni9K7BKRH7G+sB/yhjjeLqKB4F7RWQ7Vp/AW65s2FlL3w6RHViRmoEI9I0Ld3dEJ7nvws5EBPrw8OwNlJU5OoQH3g45B2BTw8qlSqmGyak+AGPMXGBupbJHKyyvxLqMU3m/pUCP09S5E+sOo4anpAgyd0G3y1i9O5POMcG/XWtvIEL9vXn4kq7cM+Nnpq/cyzUD2kCH8yGyAyx7BXpcUX0lSimPpk8CVyVrN5hSTGR71qdlkdg6zN0RVWlsYisGxEfw9De/cjS30JoicsCtsG8V7F3p7vCUUg2cJoCqpFvTMR72aUPW8WJ6xIa6OaCqiQhPju1OXmHJb/MG9BoPvjpXgFKqepoAqnJ0GwDrjlt3/vSKDXNjMGfWMSaYm4bEM3N1Gmv3ZIJvEPSZAJu+wLfgaPUVKKU8liaAqqRvh4AoVh8GHy8bnWKC3R3RGd1xXkeig315fM5Gq0M4aRJgaLl/brX7KqU8lyaAqjjuAFqflkXXFiH4eDXsX1OQrxcP/a4LP6cd49PVeyG8LXS5hJb7v4Wi4+4OTynVQDXsTzZ3Sd+OiezAhn3Z9Gqg1/8rG5vYir5tw/nXN1s4ll8MA2/HuyQH1s9wd2hKqQZKE0BlBdmQe4h0vzbkFpbQo1XjSAAiwl9HdyPjeBHPf7cV2gwiJ6g9LH8VTgwcp5RSFWgCqCxjJwC7TAwACS1D3BlNjXRvFcr4pDa8v2w3Ww7lkhY7Co78CjsXujs0pVQDpAmgsqzdAGzOj8BuEzpEB7k5oJqZcmFngny9eHzORg41GwKB0daDYUopVYkmgMoyrQSw4lgI8VGB+HrVzwTwrhIe6MP9F3bip53prDhis+YK2PZt+a2tSil1giaAyjJ3gV8Y646U0aV5w77983SuGdCWri1CmP5rEcd7TgC7Dyx/zd1hKaUaGE0AlWXtpjSsLXsz8httArDbHB3CBYZXVuVAjyth3UeQn+Xu0JRSDYgmgMoyd5PtZ01O1rl54+kAriwpPoKBLey8tmgnB7rcAMV5sPZ9d4ellGpANAFUVFYGWXs4INYdQI31DOCEqzv74GUTHllug7ZDYPnrUFpS/Y5KKY+gCaCi3INQWsiO4kiCfL2IDfd3d0RnJdzPxuRzOzB/8yE2tLkGju2BLV+5OyylVAPhVAIQkZEiskVEtovI1CrWDxORNSJSIiJXVChPFJGfRGSjiKwXkasrrJsmIqkiss7xSnRJi86G4w6gDcfD6BgThIh7J4B3hZuGxBMXGcA9a5tjwtrCslfdHZJSqoGoNgGIiB14GbgYSADGi0hCpc32ADcAH1UqPw5MNMZ0A0YC/xaRsArrpxhjEh2vdbVqgSs5ngFYnR1Ku6jGdf//6fh62Xn4kgS2HS1gRbMrYM9S2L/O3WEppRoAZ84AkoDtxpidxpgiYDowpuIGxphdxpj1QFml8q3GmG2O5f3AYaCZSyKvC5m7MAjrc0No1yzQ3dG4zPldoxnSIYp7tvXAeAdaw0MopTyeMwmgFbC3wvs0R1mNiEgS4APsqFD8d8eloedPTB7vVpm7KQ6IoQhv2jehBCAiPDIqgUNFviwLvRh+mQk5h9wdllLKzZyaE/hsiUgL4H3gemPMibOEh4CDWEnhdaxJ4p+oYt9JwCSAmJgYUlJSahVDbm5utfsm7vqZHGNN/p6eupmUo1tqdayGonKbk2Pt/HnvIBb4zmL3zEfYFX+N+4KrI878nZsabbNnqIs2O5MA9gGtK7yPdZQ5RURCgK+Ah40xy06UG2MOOBYLReQd4P6q9jfGvI6VIOjXr59JTk529tAnSUlJodp91+awP6gbtiy44uLhjW4YiMoqt7lX/yKSn01hrW8SvY8uIO66F8Dbz30B1gGn/s5NjLbZM9RFm525BLQS6Cgi8SLiA4wD5jhTuWP7z4H3jDEzK61r4fgpwFhgQw3idr2yUsjZz97ScFpHBDT6D/+qhAf6cPf5HXk2+zwk7whsmOXukJRSblRtAjDGlACTgXnAZuATY8xGEXlCREYDiEh/EUkDrgReE5GNjt2vAoYBN1Rxu+eHIvIL8AsQBTzpyobVWO5hKCthW0EY7aKazvX/yq4b2JbDkQPYKW0oW/ZfnStAKQ/mVB+AMWYuMLdS2aMVlldiXRqqvN8HwAenqfPcGkVa17Ktq1obcgJpl9A0bgGtirfdxl9GJfDaexfx9KE3YNdiiB/q7rCUUm6gTwKfcCwNgN0lEU3qFtCqJHeOJrPdGNJNCEWL/u3ucJRSbqIJ4ATHGcB+E9lkHgI7kwdH9+bd0ovwSZ0Phza5OxyllBtoAjjh2D5K7H4cI5D4JtwHcEL7ZkGU9L2J48aXzO//z93hKKXcQBPACdlpHPOOwdfLTnSw+59Jqw9/vKgfn8t5BG/9HOO4BKaU8hyaAE44to/DEkVsuD82W+MfBM4ZoQHe+A+/E4wh9ctn3R2OUqqeaQI4IXsfe0vDaRMR4O5I6tXoYQNY5DOU5ts+piAnw93hKKXqkSYAgNJiTM5BdhSGeVwC8LLbiLjgfgIoYO1n2heglCfRBACQcwDBsKvEegrY0yQmDWOjfz867PyAw5nH3B2OUqqeaAIAOGbdAnrARHhkAgCIuHAKzSSLRZ++7O5QlFL1RBMAnPQMgKddAjqhReJFHAjoTO+099iQlunucJRS9UATAJQ/BXzARHrsGQAihJ53H+1tB/h61tsYHSNIqSZPEwBAzkEKbAH4BoYS5FsvUyQ0SAGJl5PjH8sF6R/wzS8Hqt9BKdWoaQIAyDlAps1zr/+Xs3sRcO79JNp28t1X0ykoLnV3REqpOqQJACD3EAfLQmkd7u/uSNzO3vsaCgOac3X+DN5Zssvd4Sil6pAmAMDkHCStOETPAAC8fPEdfh8DbL+yfOEcDucUuDsipVQd0QRgDCbnIAdNOLF6BmDpM4GSgGbcYmby3Ldb3R2NUqqOOJUARGSkiGwRke0iMrWK9cNEZI2IlIjIFZXWXS8i2xyv6yuU9xWRXxx1vuCYGrL+FWZjK8nnsAmjZagmAAC8/fE6507OsW1gy+oFbNyvD4cp1RRVmwBExA68DFwMJADjRSSh0mZ7gBuAjyrtGwE8BgwAkoDHRCTcsfoV4Bago+M1statOBs5hwCsBBCmCaBcvz9Q5h/B3T5zeOJ/m/S2UKWaIGfOAJKA7caYncaYImA6MKbiBsaYXcaY9UBZpX0vAr4zxmQYYzKB74CRjgnhQ4wxy4z1yfIe1sTw9S/3IACHCadFmJ9bQmiQfIOwDbqd4awmd9ca5m086O6IlFIu5sxN762AvRXep2F9o3dGVfu2crzSqig/hYhMAiYBxMTEkJKS4uShT5abm1vlvtGHUkgAsiSMNcuW1Kruhup0bXaWvSSBgfYA7vebzQOz4rEf/hXvBj5U9tm2uTHSNnuGumhzg3/qyRjzOvA6QL9+/UxycnKt6klJSaHKfZesh83gExFb9fpG7LRtrgnbZEYs+heRhbvZYb+QW4e3d0lsdcUlbW5ktM2eoS7a7MwloH1A6wrvYx1lzjjdvvscy7Wp07VyD1GIL6FhkW45fIM36HbwDeUf4f/jpQXbOZJT6O6IlFIu4kwCWAl0FJF4EfEBxgFznKx/HnChiIQ7On8vBOYZYw4A2SIy0HH3z0Tgi1rEf/ZyDnCYcFrpLaBV8w+HwZPpc3wJ7Uu28dx3W9wdkVLKRapNAMaYEmAy1of5ZuATY8xGEXlCREYDiEh/EUkDrgReE5GNjn0zgL9hJZGVwBOOMoDbgTeB7cAO4GuXtsxJZdkHOVAWSgu9BfT0BtwK/hE8G/kl01fu1dtClWoinOoDMMbMBeZWKnu0wvJKTr6kU3G7t4G3qyhfBXSvSbB1oTT7AIdNM1qE6h1Ap+UXAkPupuN3jzLc73f87csIPr5lIO56dEMp5Roe/ySwLfcQR/QZgOr1vwUCo3kqfA7LdmYwb+Mhd0eklDpLnp0ACnOxl+RxyITrGUB1fAJg6H00z1jJlRE7+MfczRSW6GihSjVmnp0AcvUp4BrpewOEtOIvAZ+xJyOPaTpaqFKNmmcngBxr0pN8v2b4edvdHEwj4O0Hw+4n9Oha7mmTyot6W6hSjZpnJwDHGYAExbg5kEak9wSIaM9tJe9TVFzMc9/paKFKNVaenQDyjgLgHdrczYE0InZvOP8xfDK28GzHjcxYuYdN+7PdHZVSqhY8PAEcoRQbgWFR7o6kcek6GmL7Myr9baL9yvjblzpaqFKNkUcngLLcw2SaIKJCAt0dSuMiAhf8DVvuQV5pv4yfdqbrbaFKNUIenQCKjh3mqAklJsTX3aE0Pm0HQZdRJO55lwHRpTzxv43kFZa4OyqlVA14dAIozTlMugkhOlifAaiV8x5Dio/zYqvv2H+sgH/P1w5hpRoTj04Acvwo6YToGUBtNesEfa8nestHTO4lvL1kl3YIK9WIeHQC8CpI1zOAs5X8EHj5cVfpu4T5e/Pnz3+hrEw7hJVqDDw3ARQX4FOSSzqhRAX5uDuaxisoGoZNwXv7N7yQlM66vVl8tGKPu6NSSjnBcxPAcesZgAKfCLzsnvtrcImBt0FEOwZvfZah7UJ4+ptf9QlhpRoBz/3kyz0MQFlAMzcH0gR4+cLIp5D0bfw7fgWFxWU8Pmeju6NSSlXDqQQgIiNFZIuIbBeRqVWs9xWRGY71y0UkzlF+rYisq/AqE5FEx7oUR50n1kW7smHVcjwFLEH6EJhLdLoIOl5I5Kp/M3VYBF/9coAv1+93d1RKqTOoNgGIiB14GbgYSADGi0hCpc1uAjKNMR2A54GnAYwxHxpjEo0xicAEINUYs67CfteeWG+MOXzWramJvCMA+IToMBAuc9E/oTifG/Lfo1dsKI/M3qCXgpRqwJw5A0gCthtjdhpjioDpwJhK24wB3nUszwTOk1Onixrv2LdBKHVcAgoI14HgXCaqAwy8Ddu6D3hxWBl5RaX8ZfYvOkyEUg2UMwmgFbC3wvs0R1mV2zjmED4GRFba5mrg40pl7zgu/zxSRcKoUwVZh8g3PoSFhdfnYZu+YVMgqDltlj7M/ee1Y97GQ8z5WS8FKdUQOTUn8NkSkQHAcWPMhgrF1xpj9olIMDAL6xLRe1XsOwmYBBATE0NKSkqtYsjNzT1p39idm/AjhCN7tpNSuKtWdTZ0ldtcX5q1mUi3Tf9iROCrfBJ2IVNnrqNo/xaaBdT9PQfuarM7aZs9Q5202RhzxhcwCJhX4f1DwEOVtpkHDHIsewFHAamw/nngz2c4xg3AS9XF0rdvX1NbCxcuPOn9kVcuMWsfSTRr92TWus6GrnKb601ZmTEfXGnMky1MWuoW0/3Rb8zYlxebopLSOj+029rsRtpmz3A2bQZWmSo+U535SrYS6Cgi8SLiA4wD5lTaZg5wvWP5CmCB46CIiA24igrX/0XES0SiHMvewChgA/XIdvwo6SaU6GAdBsLlROCSZwFDq6WP8tTve7B2T5ZOHqNUA1NtAjDWNf3JWN/yNwOfGGM2isgTIjLasdlbQKSIbAfuBSreKjoM2GuM2VmhzBeYJyLrgXXAPuCNs21MTfg4hoGI1KeA60ZYGxjxZ9j6NZd4r2J8UhteSdnBoq1H3B2ZUsrBqT4AY8xcYG6lskcrLBcAV55m3xRgYKWyPKBvDWN1HWPwK84gxysMXy+dC7jODLgNfp4BXz/Ao5N+Ys3uTO6cvpY5fxpCm8gAd0enlMfzzCeBC47hZUoo9Kl8o5JyKbsXXPofyD2Ef8pfeX1iX4yBW95bRa7OHaCU23lmAnA8BVzirwmgzsX2hUGTYfU7tM1cxsvX9GH7kVzunbFORw1Vys08MwEcTwdAAjQB1IsRD0NUJ5hzJ0Nae/Pw77ry7aZD/PPrze6OTCmP5pkJID8DAK9gTQD1wtsPxr4KOfth3sPceE4cEwe15Y0fU3n1hx3ujk4pj1UvD4I1NKW5R7EDPsE6Emi9ie0L59wFi59HEsbw+KXnk3m8mKe+/pXwAG+u7t/G3REq5XE88gzg+DHrVsTA8PodgNTjJT8EzbrCnDuwFWTyf1f2YlinZkz97Bc+Wbm3+v2VUi7lkQmgMPsoxcZOaIiOA1SvvHzhsleskVj/dxc+duG16/oytGMzHpi1nneX7nJ3hEp5FI9MAMU5R8gkmEidC7j+tewN5z4Cm+fAmnfx97HzxsS+XJgQw2NzNvLct1v07iCl6olHJgBzPINME6RzAbvL4Dshfjh8PRWObMHXy87L1/bhqn6xvLBgO5M/XkN+Uam7o1SqyfPIBCD5GWQRRGSQjgPkFjYbXPYaePvDzJuguABvu42nL+/Jw7/rytcbDnLFq0vZeSTX3ZEq1aR5ZALwKswkixBC/DzyJqiGIaQFjP0vHPoF5j8OgIhwy7B2vHV9P/Zl5XPJC4v5ZOVenVBGqTrikQnAr/gY+V6h1PMcNKqyzhdD0h9h+Suw6Yvy4nO7xPD1XUNJbB3GA7PWc9O7q9iTftyNgSrVNHleAjAG/5JjFPuEujsSBXDh36BVX5j9Jzi6rby4Rag/H948gL9c0pXlO9M5//kf+Pf8rRQUa9+AUq7ieQmgMBsvSin1j3B3JAqsW0Oveg+8fGDGdVD423V/m024eWg7vr8vmYu6Neff87eR/EwK7/+0i8ISTQRKnS3PSwDHrWEg0IHgGo7QWLj8LTi6Ff53J1S65t881I8Xx/dm+qSBxIb788gXGxnxTArvLt1Fno4qqlSteVwCMI4EYA/UM4AGpf0IOPcvsGEWLH+1yk0Gtovk01sH8f5NSTQP9eOxORsZ+M/v+cfczaRlah+BUjXlVAIQkZEiskVEtovI1CrW+4rIDMf65SIS5yiPE5F8EVnneL1aYZ++IvKLY58XpJ56ZPOPHQbAOySqPg6nauKce6DzJTDvYdj+fZWbiAhDOzZj1m2DmXXbYIZ1asZbi1MZ9q+F3PzuKtYfKaFUHyRTyinVJgARsQMvAxcDCcB4EUmotNlNQKYxpgPWBPBPV1i3wxiT6HjdWqH8FeAWoKPjNbL2zXDe8SxrHCC/EB0HqMGx2eD3r0F0V/j0Bjiy5bSbigh924bz8jV9+PGBEfxxeHvW7c3kudWFDPvXQl5euJ3DOQX1F7tSjZAzZwBJwHZjzE5jTBHW5O5jKm0zBnjXsTwTOO9M3+hFpAUQYoxZ5pg8/j1gbE2Dr43CbGsyGP9QPQNokHyDYfx08PKDj66CvPRqd2kZ5s+DI7uwdOp53J7oS9vIAJ6Zt4XB/1zA5I/WsHJXhj5LoFQVnHkSqhVQcajGNGDA6bYxxpSIyDHgRC9rvIisBbKBvxhjfnRsn1apzlZVHVxEJgGTAGJiYkhJSXEi5FPl5uaSkpJCwI6NNDfC9tQ9mKyDtaqrsTjR5sYopNP9JK57mOzXR/FzrycwNm+n9ksIKiCpuRejW/qzcG8xCzYd4Mv1B2gdbOP8Nl4MbOmFr71pPf/RmP/OtaVtdo26fhT2ANDGGJMuIn2B2SLSrSYVGGNeB14H6Nevn0lOTq5VICkpKSQnJ7Nz10ccOxLIuUPPIT4qsFZ1NRYn2tw4JUO7SMJm3cTwzE+soSNs1Z+wVmzzOCC/qJTZ6/bx7tJdvLMxh1k7ypg4KI4bz4lrMkOBNO6/c+1om13DmQSwD2hd4X2so6yqbdJExAsIBdIdl3cKAYwxq0VkB9DJsX1sNXXWjfxMMk0wUQE6EFyD1+MKyEyFBU9CUDRc+CTU8F4Bfx8745PaMK5/a1buyuStxTt5OWU7by7eydX9WnPz0Ha0jgioowYo1bA5kwBWAh1FJB7rQ3occE2lbeYA1wM/AVcAC4wxRkSaARnGmFIRaYfV2bvTGJMhItkiMhBYDkwEXnRNk87MXpDBEYKJ13GAGoeh90PuEfjpJQhsBkPurlU1IkJSfARJ8RFsP5zL64t28NGKPXy4fA/jklpzx7kdiQnR4cGVZ6n2U9BxTX8yMA+wA28bYzaKyBPAKmPMHOAt4H0R2Q5kYCUJgGHAEyJSDJQBtxpjHE9icTswDfAHvna86pxPYRZ5tjBstqZ1HbjJEoGRT8HxdJj/GARGQe/rzqrKDtFB/OuKXtx9fif+m7Kd6Sv28umqNG4YHMetw9sTHqhnh8ozOPU12BgzF5hbqezRCssFwJVV7DcLmHWaOlcB3WsSrCv4lRzjuFfb+j6sOhs2G4x9BfIzYM6d4BsCCaPPutqWYf48ObYHk4a259/zt/L6jzv5cPkebhnajpuGxhPkq2eJqmnzuCeBA0qzdSC4xsjLB6563xo4buaN8OtXLqu6TWQAz12dyLy7hzGkQxTPz9/KsH8t5J0lqTrmkGrSPCsBFBfgawop9Q1zdySqNnyD4LqZ0KIXfHI9bPnGpdV3ignm1Ql9+eJP59CleTB//d8mzn/uB75Yt0+nqVRNkmclgIJj1k+/MLeGoc6CXyhc9xk07w6fTICt37r8EL1ah/HhzQN47w9JBPt6c9f0dVz60mJ+3HbE5cdSyp08KgGY/EwAbAFh7g1EnR3/MJjwuTVkxIxrXXo56AQRYVinZnx5xxD+My6RY/nFTHhrBde+uYxf0o65/HhKuYNHJYCCHCsBeAeGuzkSddb8w2HCbGjeE2ZMgHUf18lhbDZhTGIrvr9vOI9dmsDmAzlc+tJiJn+0hl1H8+rkmErVF4+6zSH32FH8AZ9gHQq6SQiIgIlfwPRrYPatjkt8XerkUL5edm48J54r+sbyxqKdvPFjKt9sOMi4pNb8cVh7fZhMNUoedQaQn209guAfrJPBNBm+QXDtp9D1UvjmQeJSPzplQhlXCvbz5t4LO/PDlGSu7t+aGSv3kvxsCnd+vJaN+/XSkGpcPCoBFOZaI0sGhWkCaFK8fOGKadD7OuJ2z4DZt0FJYZ0eMjrEj79f1oNFD4zgD+fE8f3mQ1zywmLGvf4Tn69N07mLVaPgUQmgJM/qAwgK06Ggmxy7F4x+idS4a+Dnj+H9y36b/rMOtQj15+FLElj60Hk8OLIL+7MKuGfGz/T/+3z+MvsXlmw/SnFpWZ3HoVRteFQfQOnxLI4bXyKCg9wdiqoLIuyOu5r4vufB7NvhzfPgmk8hqkOdHzrU35vbktvzx2HtWJ6awSerrOElPli2h2BfL4Z3bsbwTs1Iio+gTUQA9TQBnlJn5FEJgPxMsgmgmb9zY8urRqrHFRDaGqaPhzfPhd+/AZ0uqpdD22zCoPaRDGofyd8v687ibUeZv/kQC349zJfrDwAQFeRLQssQOkYH0TE6iPbRQTQP8SM6xBdfL3u9xKkUeFgCkMJsciWI5joQXNPXZgDcsgBmXGfNLDbsAUieCrb6+4AN8PHiwm7NubBbc8rKDNsO57JyVwZr9mSy9VAOHy5Pp6D45MtDYQHeRAf7EuLnTZCfF8F+3gT5ehHi50WQr1d5WbCfF8F+XkQG+pJdaCgtM9j137WqIY9KAF5F2Ry3Bbs7DFVfwuPgpu/gq/tg0b9g3yq4/C3r9tF6ZrMJnZsH07l5MNcNtAYjLCsz7MvKZ8eRXA5nF3Iou4DDOYUczikgp6CEjLwidqcfJ6eghNzC4lOSRUV3pcwlIsCH1hEBtIsKpF2zQNo1C6Jds0DiIgPx89YzC3Uqj0oAPiU55HjpMwAexdsfxrwMsf3h6wfg1aHWxPNxQ9wdGTab0DoiwOlnCIpKysgtLCG3oITsgmKyC4rJyCti2dqNRLRow5HcQnanH2fpjnQ+W/vb/Eoi0C4qkF6xYSTFRzCkYxSx4frcgvKwBOBfmkNRQJy7w1D1TQT63WgNIjfrJpg2yppYJvnP1iijjYSPl40ILx8iKs1XEJSxleTkzieV5RWWkHo0j51H89hxOJeN+4+xaNuR8sQQHxXIkA5RDOkYxaD2kYT4ab+YJ3IqAYjISOA/WBPCvGmMearSel/gPaAvkA5cbYzZJSIXAE8BPkARMMUYs8CxTwrQAsh3VHOhMebwWbfoDALLcijVoaA9V6s+8Mcf4ZupsPh52LEQLn8Tojq6OzKXC/T1onurULq3+u3fuzFWP8SP246yeNsRZq1J4/1lu7HbhEHtIhndqyUXdW9OqN4k4TGqTQAiYgdeBi4A0oCVIjLHGLOpwmY3AZnGmA4iMg54GrgaOApcaozZLyLdsWYVa1Vhv2sdE8PUPVNGoMnH+GoC8Gi+QTDmJeuuoDl3WJeERvwZBt5uPUvQhIkInWKC6RQTzE1D4ikqKWPtnkx+2HqEr345wAOz1vOX2RtI7tyM0YktOa9LDP4+2nfQlDnzLz4J2G6M2QkgItOBMUDFBDAGeNyxPBN4SUTEGLO2wjYbAX8R8TXG1O1jmlUpysMmxhpJUqmul0KrfvDVvfDdI7BhFox+EVr0dHdk9cbHy8aAdpEMaBfJlIs6sz7tGHN+3s+X6/fz7aZDBPl68fs+rZgwsC0dY/TmiaZITDXjpojIFcBIY8zNjvcTgAHGmMkVttng2CbN8X6HY5ujleq51RhzvuN9ChAJlGJNG/mkqSIYEZkETAKIiYnpO3369Fo1NPvgTkb/eg+zov5EZPcLa1VHY5Obm0tQkGc99FbjNhtDsyNL6bjtNbyLc9jT5jJ2t72KMnvjmSDe1X/nMmPYklHG4n0lLD9YQkkZdImwcV4bb3pH2/FqALeb6r/tmhkxYsRqY0y/yuX1cs4rIt2wLgtV/OS91hizT0SCsRLABKx+hJMYY14HXgfo16+fSU5OrlUMX8/YBkBs+y4MqGUdjU1KSgq1/X01VrVr8wg4fht8+xfarvuQtlnL4IInoPvlVgdyA1cXf+dzgduAjLwiZqzcywfLdvPyunxiQny5Jqkt45NaEx3iviSp/7Zdw5mxgPYBrSu8j3WUVbmNiHgBoVidwYhILPA5MNEYs+PEDsaYfY6fOcBHWJea6owpzAXAJ0jnAlBVCIiAsf+FG7+BgEjrbqF3LoYDP7s7MreKCPThtuT2LHpgBG9O7Efn5iE8P38rg59awOSP1rAiNYPqriKohsuZM4CVQEcRicf6oB8HXFNpmznA9cBPwBXAAmOMEZEw4CtgqjFmyYmNHUkizBhzVES8gVHA/LNtzJmYYisB+OlQ0OpM2g6CSSmw9gP4/gl4bTj0Gmc9RRwe5+7o3MZuE85PiOH8hBhSj+bxwbLdfLpqL1+uP0CX5sFMGNSWsYmtCPRt2h3pTU21ZwDGmBJgMtYdPJuBT4wxG0XkCREZ7djsLSBSRLYD9wJTHeWTgQ7AoyKyzvGKBnyBeSKyHliHlVjecGG7TlVkzd7kH6IJQFXDZoe+18Mdq2HwHbDxc3ixH3x5L2QfcHd0bhcfFcgjoxJY/ufzeer3PbCJ8PDnGxj4j+95fM5GdhzJdXeIyklOpWtjzFxgbqWyRyssFwBXVrHfk8CTp6m2r/Nhnj2b4wwgWIeCVs7yD4ML/2bdIrroGVjzLqz7EPrfDIMmQ0gLd0foVv4+dsYlteHq/q1ZsyeL93/axYfLdzNt6S6Gdoxi4qA4zu0SrWMUNWAeMx+AV3EuJcZGSEiYu0NRjU1ICxj1HExeBd0ug2WvwH96Ws8RHN3u7ujcTkTo2zacf4/rzdKp53H/hZ3YdiiXW95bxbB/LeQ/87exPyu/+opUvfOYBOBdkkcOgXjrcLuqtiLi4bJX4c410Od6WP8JvNTPmpR+9091OhVlY9Es2JfJ53Zk8YMjeOXaPsRHBfL8/K0MeXoBN76zgnkbD+oEOQ2Ix/TY+JTmkWsLQu8BUmctPA4ueRaGPwjLX4WVb8DmORDT3bo81PMq8Al0d5Ru5WW3cXGPFlzcowV7M47zyaq9fLJqL398fzWRgT5c1L05F3dvzsB2kXjbPeZ7aIPjMQnArzSP4zbPenBE1bGgZnDeIzD0XvjlU1jxJnx5N3z3GCSOh8RroHnPRvEsQV1qHRHAfRd25q7zOpKy5Qiz1+1j9tp9fLR8D2EB3lzQNYbf9WjB4A6ROiFOPfOcBFCWR4G3Ps6u6oBPIPS9wbostHc5rHwTVr1tnR1Ed7NuI+15FQQ3d3ekbuVlt5XfSlpQXMqirUf4esNBvtlwkE9XpxHs68X5CTGM7N6cIR2i9JbSeuAxv+FAk8dh71bVb6hUbYlAm4HW6+J/wcbPYN3H1lhD8x+DdiOg21jofAkEevbtyH7e9vLZ0gpLSlm6PZ25vxzg202H+HztPuw2oXurUAbER9A/LoL+ceGEBTSeobsbC49JAEHkst9HzwBUPQmIsPoD+t8MR7fBz9Oty0Rz7gC5C9qeAwljoMsoj7+d1NfLzogu0YzoEs0/SstYvjODZTvTWZGawbQlu3h90U4AujQPJik+gr5tw8nLLdNpMF3AMxKAMQSb45T5hrk7EuWJojpafQXn/gUOrodNc6xO47n3W6+WvaH9edDhfGvmsiY+LPWZeNttDOloTVQDUFBcys97s1iRmsGKXRnMXJ3Gez/tBuBvy+fRpUUw3VqGkNAilG4tQ+jcPFinv6wBj/iXVlyYh4+UgJ/OBaDcSMSalaxFLyshHNliJYLt31sT1Pz4LPiGQrthVkKIGwKRHTy6E9nP214+ZDVAcWkZWw/l8NmCFZSFtmTj/my+WLufD5btAawhK9o3CyShRQjdWobSrVUIvWLDtD/hNDzit5KTlU4EYNO5AFRD0qwzNJsCw6ZAfhak/gDb51sJYfP/rG0Cm0HbwdBmsPUzpps1VIWH8rbb6NYylCOx3iQndwOsmc72ZuSz6cAxNu7PZtP+bJbtzGD2uv0A2AS6tgihT5tw+rYNp0+bcFpH+CMenFhP8IgEkJt1lAjAHqhPAagGyj/M6hNIGGM9UHZ0G+xZaj1gtnspbPrC2s43xDqDaNnbmuKyZR+PfwBNRGgTGUCbyABGdv+tPyU9t5D1+46xdncmq/dk8pljCkyAqCCf8oRwbpdoj53wxiMSQH52OgA+mgBUYyACzTpZr743WGVZe2HPT7BnGexfa91iWloEwGDvENiXZJ0dRCdAdFeI6gTe/u5rQwMQGeTLiM7RjOgcDUBpmWHLwRzW7Mlkze5M1uzJ5NtNh/jn17/SvlkgI7s3Z2S3FnRvFeIxZwcekQAKczMA8NORQFVjFdbaevW8ynpfUgiHN8G+NaSvnkuLnEOQuqg8KSA2iGhnJYNmXa2+hIh21isgwiP7Few2IaFlCAktQ7huYFsADh4r4LtNB/lm40Fe/WEnLy/cQaswfysZdG9Ov7bhTToZeEQCKM7NBHQoaNWEePlal4Fa9mZLXntaJCdDaTFk7LQSw+HNv/389SswFcbf8Qv9LRlEtLOGtghpBaGtIaQl+AS4q1X1rnmoHxMGxTFhUBwZeUXM33yIeRsO8v5Pu3lrcSqdYoL4wznxjO3dqkneXeQRCaD0uJUAgkI1AagmzO7t6FjubI1aekJJIWTuhowdVoI48dq32prrwFQanM0/AkJbQUgshMZaSSEoBoKirU7pEz/t3vXbvjoWEejDVf1ac1W/1uQUFDNv4yHeXpzK1M9+4V/ztnDdgDZcN6gt0cGNZ77o6nhEAig7ngVASLjOBaA8kJfvb30KlZUUQXYaHNsH2fvgWNpvP7P2WB3RBceqrtc/HAKjf0sIARFWmV+Y1aldvhxuvfcLs/olGsEllWA/b67oG8vlfVqxbGcGby1O5cWF23n1h51c2qslNw2JJ6FliLvDPGtOJQARGQn8B7ADbxpjnqq03hdrQve+WHMBX22M2eVY9xBwE1AK3GmMmedMna4kBVnkGT8CvfVRcqVO4uXz26Wg0ynMhbzDkHvE8fMw5B1x/HSUH1gH+ZlWsqh8RlGR3ddKBj5B1hhKvsEVloPAJ7jCsuPlG2QlDi+/8pdf/gFrdjYvX2ud3Rdsrh9VVEQY1D6SQe0jST2ax7QlqXy6Oo1Za9IY1C6SW4bFM6JzdKPtJ6g2AYiIHXgZuABIA1aKyBxjzKYKm90EZBpjOojIOOBp4GoRScCaQ7gb0BKYLyInvoZUV6fL2IqyyZZAPHuAXqVqydfxIXymJHFCWRkUZkNBlvVsQ35m1ctFeVCUayWX3IPW+8Jcq6yo+iklBwIsr1Ro9wVvv5MSBd5+YPcBm7f1hHX58omXD9i8Ki37/Lbe5l3+Pt5m56+xdh5sDst2ZfHjtuXMfq+U1VFBXJrYmi4twqxnNMRuJSOxV3h/mnKxOZYr/Kz8QqyfprQmfzWnOHMGkARsN8bsBBCR6cAYoOKH9RjgccfyTOAlsVLiGGC6MaYQSHXMGZzk2K66Ol3Gu+gYeXhOx5ZSbmOzOS7/hFHryTfKyqD4+G8JoigHigug5LfX5l/W0rVDnNW/UZxv/SzJP2U7igugrNjqIC8psuo78b60+OTl8vdFUFZy2vACgHMdL3yAbGBRLdtaAwH9X3Z5nc4kgFbA3grv04ABp9vGGFMiIseASEf5skr7nhiSs7o6ARCRScAkgJiYGFJSUpwI+WR5Pu2BGNJqsW9jlpubW6vfV2OmbW7KBPAH/MkNSuJQbtDJq7wdL1cwBjGliCnBVlaCmBLH+zLElAFljmVDcWkpqw4WsXhvEQUlZXSLgHNb22nmZyptW3nfqtYZwCDGONad+AmZxd4u/zs3+E5gY8zrwOsA/fr1M8nJyTWvJDmZlJQUarVvI6Zt9gzaZvc7B/hDQTFvLU7lzR9T+eTnEi7rHcvd53ekdYRrrj7sq4M2O9Nrsg9oXeF9rKOsym1ExAsIxeoMPt2+ztSplFKNRrCfN3ef34lFD4zgpiHx/G/9fs79vxQen7ORIzmF7g6vSs4kgJVARxGJFxEfrE7dOZW2mQNc71i+AlhgjDGO8nEi4isi8UBHYIWTdSqlVKMTEejDw5ck8MOUZK7oG8v7y3Yz7F8LeWberxzLL3Z3eCepNgEYY0qAycA8YDPwiTFmo4g8ISKjHZu9BUQ6OnnvBaY69t0IfILVufsN8CdjTOnp6nRt05RSyn1ahPrzz9/3ZP69wzk/IYaXF+5g6NMLePH7bRw73jASgVN9AMaYucDcSmWPVlguAK48zb5/B/7uTJ1KKdXUxEcF8uL43tw6vB3PfbuV//tuK68t2sn4pNZMHBTnsj6C2mjwncBKKdUUdGsZyls39GfT/mxe/WEHby/ZxRs/ptI/LpyxvVtxSY8W9T7vsSYApZSqRwktQ3hhfG8evLgLs9fuY/bafTz8+QYen7OR4Z2iGdYpir5tw2kTEUCQr1edPmWsCUAppdygVZg/fxrRgduT27PpQDaz1+7jy/UHmL/5UPk23nYh1N+HQF87k7u5fuIfTQBKKeVGImLNX9wylD//ritpmfms2ZPJoewCso4Xk3m8mONFJdhtmS4/tiYApZRqIESE1hEBVXYM18XT3q4fPk8ppVSjoAlAKaU8lCYApZTyUJoAlFLKQ2kCUEopD6UJQCmlPJQmAKWU8lCaAJRSykOJNWx/4yAiR4Ddtdw9CjjqwnAaA22zZ9A2e4azaXNbY0yzyoWNKgGcDRFZZYzp5+446pO22TNomz1DXbRZLwEppZSH0gSglFIeypMSwOvuDsANtM2eQdvsGVzeZo/pA1BKKXUyTzoDUEopVYEmAKWU8lAekQBEZKSIbBGR7SIy1d3x1DURaS0iC0Vkk4hsFJG73B1TfRARu4isFZEv3R1LfRCRMBGZKSK/ishmERnk7pjqmojc4/g3vUFEPhYRP3fH5Goi8raIHBaRDRXKIkTkOxHZ5vgZ7opjNfkEICJ24GXgYiABGC8iCe6Nqs6VAPcZYxKAgcCfPKDNAHcBm90dRD36D/CNMaYL0Ism3nYRaQXcCfQzxnQH7MA490ZVJ6YBIyuVTQW+N8Z0BL53vD9rTT4BAEnAdmPMTmNMETAdGOPmmOqUMeaAMWaNYzkH64OhlXujqlsiEgtcArzp7ljqg4iEAsOAtwCMMUXGmCy3BlU/vAB/EfECAoD9bo7H5Ywxi4CMSsVjgHcdy+8CY11xLE9IAK2AvRXep9HEPwwrEpE4oDew3M2h1LV/Aw8AZW6Oo77EA0eAdxyXvd4UkUB3B1WXjDH7gGeBPcAB4Jgx5lv3RlVvYowxBxzLB4EYV1TqCQnAY4lIEDALuNsYk+3ueOqKiIwCDhtjVrs7lnrkBfQBXjHG9AbycNFlgYbKcd17DFbyawkEish17o2q/hnr3n2X3L/vCQlgH9C6wvtYR1mTJiLeWB/+HxpjPnN3PHXsHGC0iOzCusR3roh84N6Q6lwakGaMOXFmNxMrITRl5wOpxpgjxphi4DNgsJtjqi+HRKQFgOPnYVdU6gkJYCXQUUTiRcQHq9NojptjqlMiIljXhjcbY55zdzx1zRjzkDEm1hgTh/X3XWCMadLfDI0xB4G9ItLZUXQesMmNIdWHPcBAEQlw/Bs/jybe8V3BHOB6x/L1wBeuqNTLFZU0ZMaYEhGZDMzDumvgbWPMRjeHVdfOASYAv4jIOkfZn40xc90XkqoDdwAfOr7Y7ARudHM8dcoYs1xEZgJrsO50W0sTHBJCRD4GkoEoEUkDHgOeAj4RkZuwhsS/yiXH0qEglFLKM3nCJSCllFJV0ASglFIeShOAUkp5KE0ASinloTQBKKWUh9IEoJRSHkoTgFJKeaj/B8aev/2kCfRmAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -455,7 +454,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.9.15" }, "orig_nbformat": 4 }, diff --git a/src/torchphysics/models/deeponet/branchnets.py b/src/torchphysics/models/deeponet/branchnets.py index fe448f7a..89f7623d 100644 --- a/src/torchphysics/models/deeponet/branchnets.py +++ b/src/torchphysics/models/deeponet/branchnets.py @@ -15,29 +15,34 @@ class BranchNet(Model): ---------- function_space : Space The space of functions that can be put in this network. - output_space : Space - The space of the points that should be - returned by the parent DeepONet-model. - output_neurons : int - The number of output neurons. These neurons will only - be used internally. Will be multiplied my the dimension of the output space, - so each dimension will have the same number of intermediate neurons. - The final output of the DeepONet-model will be in the dimension of the - output space. discretization_sampler : torchphysics.sampler A sampler that will create the points at which the input functions should evaluated, to create a discrete input for the network. The number of input neurons will be equal to the number of sampled points. Therefore, the sampler should always return the same number of points! """ - def __init__(self, function_space, output_space, output_neurons, - discretization_sampler): - super().__init__(function_space, output_space) - self.output_neurons = output_neurons * output_space.dim + def __init__(self, function_space, discretization_sampler): + super().__init__(function_space, output_space=None) + self.output_neurons = 0 self.discretization_sampler = discretization_sampler self.input_dim = len(self.discretization_sampler) self.current_out = torch.empty(0) + def finalize(self, output_space, output_neurons): + """Method to set the output space and output neurons of the network. + Will be called once the BranchNet is connected to the TrunkNet, so + that both will have a fitting output shape. + + output_space : Space + The space in which the final output of the DeepONet will belong to. + output_neurons : int + The number of output neurons. Will be multiplied my the dimension of the + output space, so each dimension will have the same number of + intermediate neurons. + """ + self.output_neurons = output_neurons + self.output_space = output_space + def _reshape_multidimensional_output(self, output): return output.reshape(-1, self.output_space.dim, int(self.output_neurons/self.output_space.dim)) @@ -108,13 +113,6 @@ class FCBranchNet(BranchNet): ---------- function_space : Space The space of functions that can be put in this network. - output_space : Space - The space of the points that should be - returned by the parent DeepONet-model. - output_neurons : int - The number of output neurons. These neurons will only - be used internally. The final output of the DeepONet-model will be - in the dimension of the output space. discretization_sampler : torchphysics.sampler A sampler that will create the points at which the input functions should evaluated, to create a discrete input for the network. @@ -132,14 +130,18 @@ class FCBranchNet(BranchNet): For the weight initialization a Xavier/Glorot algorithm will be used. Default is 5/3. """ - def __init__(self, function_space, output_space, output_neurons, - discretization_sampler, hidden=(20,20,20), activations=nn.Tanh(), - xavier_gains=5/3): - super().__init__(function_space, output_space, - output_neurons, discretization_sampler) - layers = _construct_FC_layers(hidden=hidden, input_dim=self.input_dim, - output_dim=self.output_neurons, - activations=activations, xavier_gains=xavier_gains) + def __init__(self, function_space, discretization_sampler, hidden=(20,20,20), + activations=nn.Tanh(), xavier_gains=5/3): + super().__init__(function_space, discretization_sampler) + self.hidden = hidden + self.activations = activations + self.xavier_gains = xavier_gains + + def finalize(self, output_space, output_neurons): + super().finalize(output_space, output_neurons) + layers = _construct_FC_layers(hidden=self.hidden, input_dim=self.input_dim, + output_dim=self.output_neurons, activations=self.activations, + xavier_gains=self.xavier_gains) self.sequential = nn.Sequential(*layers) @@ -156,13 +158,6 @@ class ConvBranchNet1D(BranchNet): ---------- function_space : Space The space of functions that can be put in this network. - output_space : Space - The space of the points that should be - returned by the parent DeepONet-model. - output_neurons : int - The number of output neurons. These neurons will only - be used internally. The final output of the DeepONet-model will be - in the dimension of the output space. discretization_sampler : torchphysics.sampler A sampler that will create the points at which the input functions should evaluated, to create a discrete input for the network. @@ -191,15 +186,19 @@ class ConvBranchNet1D(BranchNet): For the weight initialization a Xavier/Glorot algorithm will be used. Default is 5/3. """ - def __init__(self, function_space, output_space, output_neurons, - discretization_sampler, convolutional_network, + def __init__(self, function_space, discretization_sampler, convolutional_network, hidden=(20,20,20), activations=nn.Tanh(), xavier_gains=5/3): - super().__init__(function_space, output_space, - output_neurons, discretization_sampler) + super().__init__(function_space, discretization_sampler) self.conv_net = convolutional_network - layers = _construct_FC_layers(hidden=hidden, input_dim=self.input_dim, - output_dim=self.output_neurons, - activations=activations, xavier_gains=xavier_gains) + self.hidden = hidden + self.activations = activations + self.xavier_gains = xavier_gains + + def finalize(self, output_space, output_neurons): + super().finalize(output_space, output_neurons) + layers = _construct_FC_layers(hidden=self.hidden, input_dim=self.input_dim, + output_dim=self.output_neurons, activations=self.activations, + xavier_gains=self.xavier_gains) self.sequential = nn.Sequential(*layers) diff --git a/src/torchphysics/models/deeponet/deeponet.py b/src/torchphysics/models/deeponet/deeponet.py index 6b2d9376..fa8a13ca 100644 --- a/src/torchphysics/models/deeponet/deeponet.py +++ b/src/torchphysics/models/deeponet/deeponet.py @@ -19,6 +19,15 @@ class DeepONet(Model): branch_net : torchphysics.models.BranchNet The neural network that will get the function variables as an input. + output_space : Space + The space in which the final output of the DeepONet will belong to. + output_neurons : int + The number of output neurons, that will be the output of the + TrunkNet and BranchNet. The corresponding outputs of both networks + are then connected with the inner product. + For higher dimensional outputs, will be multiplied my the dimension of + the output space, so each dimension will have the same number of + intermediate neurons. Notes ----- @@ -28,12 +37,13 @@ class DeepONet(Model): and George Em Karniadakis, "Learning nonlinear operators via DeepONet based on the universal approximation theorem of operators", 2021 """ - def __init__(self, trunk_net, branch_net): + def __init__(self, trunk_net, branch_net, output_space, output_neurons): self._check_trunk_and_branch_correct(trunk_net, branch_net) super().__init__(input_space=trunk_net.input_space, - output_space=trunk_net.output_space) + output_space=output_space) self.trunk = trunk_net self.branch = branch_net + self._finalize_trunk_and_branch(output_space, output_neurons) def _check_trunk_and_branch_correct(self, trunk_net, branch_net): """Checks if the trunk and branch net are compatible @@ -43,9 +53,14 @@ def _check_trunk_and_branch_correct(self, trunk_net, branch_net): trunk_net = trunk_net.models[-1] assert isinstance(trunk_net, TrunkNet) assert isinstance(branch_net, BranchNet) - assert trunk_net.output_space == branch_net.output_space - assert trunk_net.output_neurons == branch_net.output_neurons, \ - "Number of output neurons in the branch and trunk net are not the same!" + + def _finalize_trunk_and_branch(self, output_space, output_neurons): + if isinstance(self.trunk, Sequential): + self.trunk.models[-1].finalize(output_space, output_neurons) + else: + self.trunk.finalize(output_space, output_neurons) + self.branch.finalize(output_space, output_neurons) + def forward(self, trunk_inputs, branch_inputs=None, device='cpu'): """Apply the network to the given inputs. diff --git a/src/torchphysics/models/deeponet/trunknets.py b/src/torchphysics/models/deeponet/trunknets.py index c3e1f946..3b77d611 100644 --- a/src/torchphysics/models/deeponet/trunknets.py +++ b/src/torchphysics/models/deeponet/trunknets.py @@ -13,13 +13,6 @@ class TrunkNet(Model): ---------- input_space : Space The space of the points that can be put into this model. - output_space : Space - The number of output neurons. These neurons will only - be used internally. The final output of the DeepONet-model will be - in the dimension of the output space. - output_neurons : int - The number of output neurons. Will be multiplied my the dimension of the output space, - so each dimension will have the same number of intermediate neurons. trunk_input_copied : bool, optional If every sample function of the branch input gets evaluated at the same trunk input, the evaluation process can be speed up, since the trunk only has to evaluated once @@ -29,12 +22,26 @@ class TrunkNet(Model): is used, set trunk_input_copied = False. Else this may lead to unexpected behavior. """ - def __init__(self, input_space, output_space, output_neurons, - trunk_input_copied=True): - super().__init__(input_space, output_space) - self.output_neurons = output_neurons * output_space.dim + def __init__(self, input_space, trunk_input_copied=True): + super().__init__(input_space, output_space=None) + self.output_neurons = 0 self.trunk_input_copied = trunk_input_copied + def finalize(self, output_space, output_neurons): + """Method to set the output space and output neurons of the network. + Will be called once the BranchNet is connected to the TrunkNet, so + that both will have a fitting output shape. + + output_space : Space + The space in which the final output of the DeepONet will belong to. + output_neurons : int + The number of output neurons. Will be multiplied my the dimension of the + output space, so each dimension will have the same number of + intermediate neurons. + """ + self.output_neurons = output_neurons + self.output_space = output_space + def _reshape_multidimensional_output(self, output): if len(output.shape) == 3: return output.reshape(output.shape[0], output.shape[1], self.output_space.dim, @@ -42,6 +49,8 @@ def _reshape_multidimensional_output(self, output): return output.reshape(-1, self.output_space.dim, int(self.output_neurons/self.output_space.dim)) + + def construct_FC_trunk_layers(hidden, input_dim, output_dim, activations, xavier_gains): """Constructs the layer structure for a fully connected neural network. """ @@ -62,19 +71,13 @@ def construct_FC_trunk_layers(hidden, input_dim, output_dim, activations, xavier torch.nn.init.xavier_normal_(layers[-1].weight, gain=1) return layers + class FCTrunkNet(TrunkNet): """A fully connected neural network that can be used inside a DeepONet. Parameters ---------- input_space : Space The space of the points the can be put into this model. - output_space : Space - The space of the points that should be - returned by the parent DeepONet-model. - output_neurons : int - The number of output neurons. These neurons will only - be used internally. The final output of the DeepONet-model will be - in the dimension of the output space. hidden : list or tuple The number and size of the hidden layers of the neural network. The lenght of the list/tuple will be equal to the number @@ -87,21 +90,25 @@ class FCTrunkNet(TrunkNet): For the weight initialization a Xavier/Glorot algorithm will be used. Default is 5/3. """ - def __init__(self, input_space, output_space, output_neurons, - hidden=(20,20,20), activations=nn.Tanh(), xavier_gains=5/3, + def __init__(self, input_space, hidden=(20,20,20), activations=nn.Tanh(), xavier_gains=5/3, trunk_input_copied=True): - super().__init__(input_space, output_space, output_neurons, - trunk_input_copied=trunk_input_copied) + super().__init__(input_space, trunk_input_copied=trunk_input_copied) + self.hidden = hidden + self.activations = activations + self.xavier_gains = xavier_gains + + def finalize(self, output_space, output_neurons): + super().finalize(output_space, output_neurons) # special layer architecture is used if trunk data is copied -> faster training if self.trunk_input_copied: - layers = construct_FC_trunk_layers(hidden=hidden, input_dim=self.input_space.dim, - output_dim=self.output_neurons, - activations=activations, xavier_gains=xavier_gains) + layers = construct_FC_trunk_layers(hidden=self.hidden, input_dim=self.input_space.dim, + output_dim=self.output_neurons, activations=self.activations, + xavier_gains=self.xavier_gains) else: - layers = _construct_FC_layers(hidden=hidden, input_dim=self.input_space.dim, - output_dim=self.output_neurons, - activations=activations, xavier_gains=xavier_gains) + layers = _construct_FC_layers(hidden=self.hidden, input_dim=self.input_space.dim, + output_dim=self.output_neurons, activations=self.activations, + xavier_gains=self.xavier_gains) self.sequential = nn.Sequential(*layers) diff --git a/src/torchphysics/utils/data/deeponet_dataloader.py b/src/torchphysics/utils/data/deeponet_dataloader.py index f7799d9f..61e15808 100644 --- a/src/torchphysics/utils/data/deeponet_dataloader.py +++ b/src/torchphysics/utils/data/deeponet_dataloader.py @@ -17,7 +17,7 @@ class DeepONetDataLoader(torch.utils.data.DataLoader): [number_of_functions, discrete_points_of_branch_net, function_space_dim] For example, if we have a batch of 20 vector-functions (:math:`f:\R \to \R^2`) and use 100 discrete points for the evaluation (where the branch nets evaluates f), - the shape would be: [50, 100, 2] + the shape would be: [20, 100, 2] trunk_data : torch.tensor A tensor containing the input data for the trunk network. There are two different possibilites for the shape of this data: diff --git a/tests/tests_models/test_deep_o_net.py b/tests/tests_models/test_deep_o_net.py index 6c3224f0..aabf0f20 100644 --- a/tests/tests_models/test_deep_o_net.py +++ b/tests/tests_models/test_deep_o_net.py @@ -15,24 +15,24 @@ """ def test_create_trunk_net(): - net = TrunkNet(input_space=R2('x'), output_space=R1('u'), output_neurons=20) + net = TrunkNet(input_space=R2('x')) assert net.input_space == R2('x') - assert net.output_space == R1('u') - assert net.output_neurons == 20 + assert net.output_space == None + assert net.output_neurons == 0 def test_create_fc_trunk_net(): - net = FCTrunkNet(input_space=R2('x'), output_space=R1('u'), output_neurons=20) + net = FCTrunkNet(input_space=R2('x')) assert net.input_space == R2('x') - assert net.output_space == R1('u') - assert net.output_neurons == 20 + assert net.output_space == None + assert net.output_neurons == 0 def test_forward_fc_trunk_net(): - net = FCTrunkNet(input_space=R2('x'), output_space=R1('u'), output_neurons=20) - test_data = Points(torch.tensor([[[2, 3.0], [0, 1]], [[2, 3.0], [0, 1]]]), R2('x')) - out = net(test_data) - assert out.size() == torch.Size([2, 2, 1, 20]) + net = FCTrunkNet(input_space=R2('x')) + assert net.input_space == R2('x') + assert net.output_space == None + assert net.output_neurons == 0 """ Tests for branch net: @@ -50,62 +50,44 @@ def f(k, t): def test_create_branch_net(): fn_space, _ = helper_fn_set() sampler = GridSampler(fn_space.input_domain, 10).make_static() - net = BranchNet(fn_space, output_space=R1('u'), output_neurons=20, - discretization_sampler=sampler) + net = BranchNet(fn_space, discretization_sampler=sampler) assert net.discretization_sampler == sampler - assert net.output_space == R1('u') - assert net.output_neurons == 20 assert net.input_dim == 10 assert net.input_space == fn_space -def test_discretization_of_function_set(): - fn_space, fn_set = helper_fn_set() - fn_set.sample_params() - sampler = GridSampler(fn_space.input_domain, 10).make_static() - net = BranchNet(fn_space, output_space=R1('u'), output_neurons=20, - discretization_sampler=sampler) - fn_batch = net._discretize_function_set(fn_set) - assert fn_batch.shape == (20, 10) - - def test_create_fc_branch_net(): fn_space, _ = helper_fn_set() sampler = GridSampler(fn_space.input_domain, 15).make_static() - net = FCBranchNet(fn_space, output_space=R1('u'), output_neurons=22, - discretization_sampler=sampler) + net = FCBranchNet(fn_space, discretization_sampler=sampler) assert net.discretization_sampler == sampler - assert net.output_space == R1('u') - assert net.output_neurons == 22 assert net.input_dim == 15 assert net.input_space == fn_space -def test_fix_branch_net_with_function(): - def f(t): - return 20*t - fn_space, _ = helper_fn_set() - sampler = GridSampler(fn_space.input_domain, 15).make_static() - net = FCBranchNet(fn_space, output_space=R1('u'), output_neurons=22, - discretization_sampler=sampler) - net.fix_input(f) - assert net.current_out.shape == (1, 1, 22) +# def test_fix_branch_net_with_function(): +# def f(t): +# return 20*t +# fn_space, _ = helper_fn_set() +# sampler = GridSampler(fn_space.input_domain, 15).make_static() +# net = FCBranchNet(fn_space, output_space=R1('u'), output_neurons=22, +# discretization_sampler=sampler) +# net.fix_input(f) +# assert net.current_out.shape == (1, 1, 22) def test_fix_branch_net_with_function_set(): fn_space, fn_set = helper_fn_set() sampler = GridSampler(fn_space.input_domain, 15).make_static() - net = FCBranchNet(fn_space, output_space=R1('u'), output_neurons=22, - discretization_sampler=sampler) + net = FCBranchNet(fn_space, discretization_sampler=sampler) + net.finalize(R1('u'), 20) net.fix_input(fn_set) - assert net.current_out.shape == (20, 1, 22) def test_fix_branch_wrong_input(): fn_space, _ = helper_fn_set() sampler = GridSampler(fn_space.input_domain, 15).make_static() - net = FCBranchNet(fn_space, output_space=R1('u'), output_neurons=22, - discretization_sampler=sampler) + net = FCBranchNet(fn_space, discretization_sampler=sampler) with pytest.raises(NotImplementedError): net.fix_input(34) @@ -113,26 +95,28 @@ def test_fix_branch_wrong_input(): Tests for DeepONet: """ def test_create_deeponet(): - trunk = TrunkNet(input_space=R1('t'), output_space=R1('u'), output_neurons=20) + trunk = TrunkNet(input_space=R1('t')) fn_space, _ = helper_fn_set() sampler = GridSampler(fn_space.input_domain, 15).make_static() - branch = FCBranchNet(fn_space, output_space=R1('u'), output_neurons=20, - discretization_sampler=sampler) - net = DeepONet(trunk, branch) + branch = FCBranchNet(fn_space, discretization_sampler=sampler) + net = DeepONet(trunk, branch, output_space=R1('u'), output_neurons=20) assert net.trunk == trunk assert net.branch == branch assert net.input_space == R1('t') assert net.output_space == R1('u') + assert net.trunk.output_space == R1('u') + assert net.branch.output_space == R1('u') + assert net.trunk.output_neurons == 20 + assert net.branch.output_neurons == 20 def test_create_deeponet_with_seq_trunk(): - trunk = TrunkNet(input_space=R1('t'), output_space=R1('u'), output_neurons=20) + trunk = TrunkNet(input_space=R1('t')) seq_trunk = Sequential(NormalizationLayer(Interval(R1('t'), 0, 1)), trunk) fn_space, _ = helper_fn_set() sampler = GridSampler(fn_space.input_domain, 15).make_static() - branch = FCBranchNet(fn_space, output_space=R1('u'), output_neurons=20, - discretization_sampler=sampler) - net = DeepONet(seq_trunk, branch) + branch = FCBranchNet(fn_space, discretization_sampler=sampler) + net = DeepONet(seq_trunk, branch, output_space=R1('u'), output_neurons=20) assert net.trunk == seq_trunk assert net.branch == branch assert net.input_space == R1('t') @@ -142,12 +126,11 @@ def test_create_deeponet_with_seq_trunk(): def test_deeponet_fix_branch(): def f(t): return 20*t - trunk = TrunkNet(input_space=R1('t'), output_space=R1('u'), output_neurons=20) + trunk = TrunkNet(input_space=R1('t')) fn_space, _ = helper_fn_set() sampler = GridSampler(fn_space.input_domain, 15).make_static() - branch = FCBranchNet(fn_space, output_space=R1('u'), output_neurons=20, - discretization_sampler=sampler) - net = DeepONet(trunk, branch) + branch = FCBranchNet(fn_space, discretization_sampler=sampler) + net = DeepONet(trunk, branch, output_space=R1('u'), output_neurons=20) net.fix_branch_input(f) assert branch.current_out.shape == (1, 1, 20) @@ -155,27 +138,41 @@ def f(t): def test_deeponet_forward(): def f(t): return 20*t - trunk = FCTrunkNet(input_space=R1('t'), output_space=R1('u'), output_neurons=20) + trunk = FCTrunkNet(input_space=R1('t'), xavier_gains=(1, 1, 1), + trunk_input_copied=False) fn_space, _ = helper_fn_set() sampler = GridSampler(fn_space.input_domain, 15).make_static() - branch = FCBranchNet(fn_space, output_space=R1('u'), output_neurons=20, - discretization_sampler=sampler) - net = DeepONet(trunk, branch) + branch = FCBranchNet(fn_space, discretization_sampler=sampler, xavier_gains=(1, 1, 1)) + net = DeepONet(trunk, branch, output_space=R1('u'), output_neurons=20) test_data = Points(torch.tensor([[[2], [0], [3.4], [2.9]]]), R1('t')) out = net(test_data, f) assert 'u' in out.space assert out.as_tensor.shape == (1, 4, 1) +def test_deeponet_forward_multi_dim_output(): + def f(t): + return 20*t + trunk = FCTrunkNet(input_space=R1('t'), activations=[torch.nn.ReLU()], hidden=(10,)) + fn_space, _ = helper_fn_set() + sampler = GridSampler(fn_space.input_domain, 15).make_static() + branch = FCBranchNet(fn_space, discretization_sampler=sampler, + activations=[torch.nn.ReLU()], hidden=(10,)) + net = DeepONet(trunk, branch, output_space=R2('u'), output_neurons=20) + test_data = Points(torch.tensor([[[2], [0], [3.4], [2.9]]]), R1('t')) + out = net(test_data, f) + assert 'u' in out.space + assert out.as_tensor.shape == (1, 4, 2) + + def test_deeponet_forward_with_fixed_branch(): def f(t): return torch.sin(t) - trunk = FCTrunkNet(input_space=R1('t'), output_space=R1('u'), output_neurons=20) + trunk = FCTrunkNet(input_space=R1('t')) fn_space, _ = helper_fn_set() sampler = GridSampler(fn_space.input_domain, 15).make_static() - branch = FCBranchNet(fn_space, output_space=R1('u'), output_neurons=20, - discretization_sampler=sampler) - net = DeepONet(trunk, branch) + branch = FCBranchNet(fn_space, discretization_sampler=sampler) + net = DeepONet(trunk, branch, output_space=R1('u'), output_neurons=12) test_data = Points(torch.tensor([[[2], [0], [3.4], [2.9], [5.2]]]), R1('t')) net.fix_branch_input(f) out = net(test_data) @@ -184,15 +181,15 @@ def f(t): def test_deeponet_forward_branch_intern(): - trunk = FCTrunkNet(input_space=R1('t'), output_space=R1('u'), output_neurons=20) + trunk = FCTrunkNet(input_space=R1('t')) fn_space, fn_set = helper_fn_set() sampler = GridSampler(fn_space.input_domain, 15).make_static() - branch = FCBranchNet(fn_space, output_space=R1('u'), output_neurons=20, - discretization_sampler=sampler) - net = DeepONet(trunk, branch) + branch = FCBranchNet(fn_space, discretization_sampler=sampler) + net = DeepONet(trunk, branch, output_space=R1('u'), output_neurons=20) net._forward_branch(fn_set, iteration_num=0) net._forward_branch(fn_set, iteration_num=0) + def test_trunk_linear(): linear_a = TrunkLinear(30, 20, bias=True) linear_b = torch.nn.Linear(30, 20, bias=True) From e0b2e972c45bac482a641dc3be58d96b81df7cef Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Fri, 9 Jun 2023 11:06:46 +0200 Subject: [PATCH 20/30] Add better error messages Signed-off-by: Tom Freudenberg --- CHANGELOG.rst | 7 ++++--- src/torchphysics/problem/spaces/points.py | 3 ++- src/torchphysics/utils/data/deeponet_dataloader.py | 11 +++++++++-- src/torchphysics/utils/user_fun.py | 2 +- 4 files changed, 16 insertions(+), 7 deletions(-) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 33beb4eb..328bae43 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -8,7 +8,8 @@ Version 1.0 =========== First official release of TorchPhysics on PyPI. -Version 1.1.0 +Version 1.0.1 ============= - - Updated documentation. - - Simplyfied creation/definition of DeepONets. \ No newline at end of file + - Updated documentation and error messages. + - Simplyfied creation/definition of DeepONets. + - Add evalution of the DeepONet for discrete inputs. \ No newline at end of file diff --git a/src/torchphysics/problem/spaces/points.py b/src/torchphysics/problem/spaces/points.py index 13f225d2..76526793 100644 --- a/src/torchphysics/problem/spaces/points.py +++ b/src/torchphysics/problem/spaces/points.py @@ -31,7 +31,8 @@ def __init__(self, data, space, **kwargs): self._t = torch.as_tensor(data, **kwargs) self.space = space assert len(self._t.shape) >= 2 - assert self._t.shape[-1] == self.space.dim + assert self._t.shape[-1] == self.space.dim, \ + "Data dimension does not fit dimension of the space " + str(list(self.space.keys())) @classmethod def empty(cls, **kwargs): diff --git a/src/torchphysics/utils/data/deeponet_dataloader.py b/src/torchphysics/utils/data/deeponet_dataloader.py index 61e15808..15de15f5 100644 --- a/src/torchphysics/utils/data/deeponet_dataloader.py +++ b/src/torchphysics/utils/data/deeponet_dataloader.py @@ -33,9 +33,9 @@ class DeepONetDataLoader(torch.utils.data.DataLoader): A tensor containing the expected output of the network. Shape of the data should be: [number_of_functions, number_of_trunk_points, output_dim]. - branch_output_space : torchphysics.spaces.Space + branch_space : torchphysics.spaces.Space The output space of the functions, that are used as the branch input. - input_space : torchphysics.spaces.Space + trunk_space : torchphysics.spaces.Space The input space of the trunk network. output_space : torchphysics.spaces.Space The output space in which the solution is. @@ -54,6 +54,13 @@ def __init__(self, branch_data, trunk_data, output_data, branch_space, trunk_space, output_space, branch_batch_size, trunk_batch_size, shuffle_branch=False, shuffle_trunk=True, num_workers=0, pin_memory=False): + assert len(branch_data.shape) == 3, "Branch data has the wrong shape" + assert branch_data.shape[-1] == branch_space.dim , \ + "Branch data dimension is not correct, is " + str(branch_data.shape[-1]) + " but expected " + str(branch_space.dim) + assert trunk_data.shape[-1] == trunk_space.dim, \ + "Trunk data dimension is not correct, is " + str(trunk_data.shape[-1]) + " but expected " + str(trunk_space.dim) + assert output_data.shape[-1] == output_space.dim, \ + "Solution data dimension is not correct, is " + str(output_data.shape[-1]) + " but expected " + str(output_space.dim) if len(trunk_data.shape) == 3: super().__init__(DeepONetDataset_Unique(branch_data, trunk_data, diff --git a/src/torchphysics/utils/user_fun.py b/src/torchphysics/utils/user_fun.py index f7407cce..ad7690ba 100644 --- a/src/torchphysics/utils/user_fun.py +++ b/src/torchphysics/utils/user_fun.py @@ -94,7 +94,7 @@ def __call__(self, args={}, vectorize=False): # check that every necessary arg is given for key in self.necessary_args: assert key in args, \ - f"The argument '{key}' is necessary in {self.__name__} but not given." + f"The argument '{key}' is necessary in {self.__name__()} but not given." # if necessary, pass defaults inp = {key: args[key] for key in self.args if key in args} inp.update({key: self.defaults[key] for key in self.args if key not in args}) From 212902777ceff5a3a0c9d419e3f1c896390083a9 Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Fri, 9 Jun 2023 11:07:23 +0200 Subject: [PATCH 21/30] extend DeepONet to allow discrete inputs Signed-off-by: Tom Freudenberg --- .../models/deeponet/branchnets.py | 20 +++++++++++++++---- src/torchphysics/models/deeponet/deeponet.py | 2 +- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/src/torchphysics/models/deeponet/branchnets.py b/src/torchphysics/models/deeponet/branchnets.py index 89f7623d..05d34d0a 100644 --- a/src/torchphysics/models/deeponet/branchnets.py +++ b/src/torchphysics/models/deeponet/branchnets.py @@ -80,7 +80,8 @@ def fix_input(self, function, device='cpu'): Parameters ---------- - function : callable, torchphysics.domains.FunctionSet + function : callable, torchphysics.domains.FunctionSet, torch.Tensor, + torchphysics.spaces.Points The function(s) for which the network should be evaluaded. device : str, optional The device where the data lays. Default is 'cpu'. @@ -90,8 +91,6 @@ def fix_input(self, function, device='cpu'): To overwrite the data ``current_out`` (the fixed function) just call ``.fix_input`` again with a new function. """ - # TODO: add functionality for list of functions and already - # discrete function tensor if isinstance(function, FunctionSet): function.sample_params(device=device) discrete_fn = self._discretize_function_set(function, device=device) @@ -101,8 +100,21 @@ def fix_input(self, function, device='cpu'): discrete_fn = function(discrete_points) discrete_fn = discrete_fn.unsqueeze(0) # add batch dimension discrete_fn = Points(discrete_fn, self.input_space.output_space) + elif isinstance(function, Points): + # check if we have to add batch dimension + if len(function._t.shape) < 3: + discrete_fn = Points(function._t.unsqueeze(0), self.input_space.output_space) + else: + discrete_fn = function + elif isinstance(function, torch.Tensor): + # check if we have to add batch dimension + if len(function.shape) < 3: + discrete_fn = function.unsqueeze(0) + discrete_fn = Points(discrete_fn, self.input_space.output_space) + else: + discrete_fn = Points(function, self.input_space.output_space) else: - raise NotImplementedError("function has to be callable or a FunctionSet") + raise NotImplementedError("Function has to be callable, a FunctionSet, a tensor, or a tp.Point") self(discrete_fn) diff --git a/src/torchphysics/models/deeponet/deeponet.py b/src/torchphysics/models/deeponet/deeponet.py index fa8a13ca..e10f37dc 100644 --- a/src/torchphysics/models/deeponet/deeponet.py +++ b/src/torchphysics/models/deeponet/deeponet.py @@ -81,7 +81,7 @@ def forward(self, trunk_inputs, branch_inputs=None, device='cpu'): A point object containing the output. """ - if branch_inputs: + if not branch_inputs is None: self.fix_branch_input(branch_inputs, device=device) trunk_out = self.trunk(trunk_inputs) if len(trunk_out.shape) < 4: From 9620ef3f5ba76801e39726b6389106d178622303 Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Fri, 30 Jun 2023 12:36:35 +0200 Subject: [PATCH 22/30] Add workshop-folder Signed-off-by: Tom Freudenberg --- examples/workshop/workshop_example.ipynb | 409 +++++++++++++++++++++++ 1 file changed, 409 insertions(+) create mode 100644 examples/workshop/workshop_example.ipynb diff --git a/examples/workshop/workshop_example.ipynb b/examples/workshop/workshop_example.ipynb new file mode 100644 index 00000000..61556f04 --- /dev/null +++ b/examples/workshop/workshop_example.ipynb @@ -0,0 +1,409 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n", + "import torch\n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[[18.5000+0.0000j, -3.5000+1.0000j, -7.5000+0.0000j],\n", + " [-3.5000+2.0000j, 1.0000+0.5000j, 2.5000-2.0000j],\n", + " [-1.5000+0.0000j, 0.5000+0.0000j, 0.5000+0.0000j],\n", + " [-3.5000-2.0000j, 0.0000+0.5000j, 2.5000+2.0000j]],\n", + "\n", + " [[15.5000+0.0000j, -3.7500+2.7500j, -5.0000+0.0000j],\n", + " [-0.5000+4.0000j, 1.2500+1.2500j, -0.5000-3.5000j],\n", + " [-0.5000+0.0000j, 0.7500+1.2500j, 0.0000+0.0000j],\n", + " [-0.5000-4.0000j, -0.2500+0.7500j, -0.5000+3.5000j]]]) torch.Size([2, 4, 4]) torch.Size([2, 4, 3])\n", + "tensor([[[ 4.0000+0.j, -2.0000+0.j],\n", + " [-1.0000+0.j, 1.0000+0.j]],\n", + "\n", + " [[ 1.5000+0.j, -0.5000+0.j],\n", + " [ 1.5000+0.j, -0.5000+0.j]]])\n" + ] + } + ], + "source": [ + "x = torch.tensor((2, 4))\n", + "a = torch.tensor([[[1, 2, 3, 4], [1, 4, 5, 6], [1, 9, 5, 9], [1, 9, 5, 9]], \n", + " [[1, 2, 3, 8], [0, 0, 5, 3], [1, 4, 5, 6], [1, 9, 5, 9]]])\n", + "padding = torch.zeros(2*len(x), dtype=torch.int32)\n", + "padding[1::2] = torch.flip(torch.floor((x - torch.tensor(a.shape[1:])) / 2.0), \n", + " dims=(0,))\n", + "fft = torch.fft.rfftn(a, dim=(1, 2), norm=\"ortho\")\n", + "print(fft, a.shape, fft.shape)\n", + "fft = torch.fft.rfft2(a, s=(2, 2), norm=\"ortho\")\n", + "print(fft)\n", + "#fft_split = torch.fft.fft(torch.fft.fft(a, dim=2), dim=1)\n", + "#print(torch.abs(fft_split - fft))\n", + "#fft = torch.nn.functional.pad(\n", + "# torch.fft.rfftn(a, dim=(-1, -2), norm=\"ortho\"), \n", + "# padding.tolist()) # here remove to high freq.\n", + "#print(padding, fft.shape)\n", + "#print((torch.nn.functional.pad(fft, (-padding).tolist())).shape)\n", + "#weighted_fft = fft\n", + "#ifft = torch.fft.irfftn(\n", + "# torch.nn.functional.pad(weighted_fft, (-padding).tolist()), # here add high freq.\n", + "# dim=(-1, -2), norm=\"ortho\")\n", + "#ifft" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([ 0, -1, 0, -1], dtype=torch.int32) tensor([[[ 2.1213+0.j, -0.7071+0.j]],\n", + "\n", + " [[ 2.1213+0.j, -0.7071+0.j]]])\n", + "tensor([[[19.9006+0.0000j, -5.8753+1.0731j, -1.7928-1.7364j],\n", + " [ 0.1826+2.5298j, 1.7317+2.6037j, 0.9396+0.0542j],\n", + " [ 0.1826-2.5298j, 0.1402+2.9430j, -2.5377+1.4542j]],\n", + "\n", + " [[ 1.6432+0.0000j, 0.2257-1.8690j, -0.5908-1.6350j],\n", + " [-2.7386+0.0000j, 0.6699-0.6000j, 0.7145+1.0904j],\n", + " [-2.7386+0.0000j, 0.3691-0.3815j, 0.5286+1.6625j]]])\n" + ] + }, + { + "data": { + "text/plain": [ + "tensor([[[0.1826, 0.4349, 0.8431, 0.8431, 0.4349],\n", + " [0.1826, 0.4349, 0.8431, 0.8431, 0.4349],\n", + " [0.1826, 0.4349, 0.8431, 0.8431, 0.4349]],\n", + "\n", + " [[0.1826, 0.4349, 0.8431, 0.8431, 0.4349],\n", + " [0.1826, 0.4349, 0.8431, 0.8431, 0.4349],\n", + " [0.1826, 0.4349, 0.8431, 0.8431, 0.4349]]])" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = torch.tensor((1, 2))\n", + "a = torch.tensor([[[1, 2, 3, 4, 5], [1, 4, 5, 6, 2], [1, 9, 5, 9, 2]], \n", + " [[1, 2, 3, 8, 8], [0, 0, 5, 3, 2], [1, 4, 5, 6, 2]]])\n", + "padding = torch.zeros(2*len(x), dtype=torch.int32)\n", + "padding[1::2] = torch.flip((x - torch.tensor(a.shape[1:])), \n", + " dims=(0,)) / 2\n", + "fft = torch.fft.rfftn(a, s=x.tolist(), norm=\"ortho\") \n", + "print(padding, fft)\n", + "print(torch.fft.rfftn(a, norm=\"ortho\") )\n", + "weighted_fft = fft\n", + "ifft = torch.fft.irfftn(fft, s=(3, 5), norm=\"ortho\")\n", + "ifft" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = torch.ones((5, 4, 100, 10))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n", + " 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n", + " 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n", + " 0.0000e+00, 0.0000e+00],\n", + " [6.1426e-09, 3.0781e-08, 1.1931e-07, 1.1947e-07, 1.7126e-08, 1.7883e-07,\n", + " 7.9779e-10, 5.9652e-08, 6.1000e-08, 2.9829e-08, 2.1280e-08, 8.3902e-09,\n", + " 5.9777e-08, 6.0192e-08, 1.7875e-09, 1.2602e-09, 1.4750e-08, 5.9639e-08,\n", + " 5.9693e-08, 2.9871e-08]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = torch.ones((2, 20))\n", + "a[1, :] = torch.sin(torch.linspace(0, 6, 20))\n", + "b = torch.fft.fftn(a, dim=1, norm=\"ortho\")\n", + "torch.abs(torch.fft.ifftn(b, dim=1, norm=\"ortho\") - a)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "t_end = 3.0\n", + "D_min, D_max = 0.01, 1.0\n", + "g = 9.81\n", + "H = 50.0" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "T = tp.spaces.R1('t')\n", + "D = tp.spaces.R1('D')\n", + "X = tp.spaces.R1('x')\n", + "\n", + "int_t = tp.domains.Interval(T, 0, t_end)\n", + "int_D = tp.domains.Interval(D, D_min, D_max)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "model = tp.models.FCN(T*D, X, hidden=(20, 20))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def ode_residual(x, t, D):\n", + " #x *= 50.0\n", + " x_t = tp.utils.grad(x, t)\n", + " #x_tt = tp.utils.grad(x_t, t)\n", + " return x_t - D * x**2 + g\n", + "\n", + "ode_sampler = tp.samplers.RandomUniformSampler(int_t * int_D, n_points=5000)\n", + "\n", + "ode_condition = tp.conditions.PINNCondition(model, ode_sampler, ode_residual)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def initial_residual(x):\n", + " x *= 50.0\n", + " return x - H\n", + "\n", + "initial_sampler = tp.samplers.RandomUniformSampler(int_t.boundary_left * int_D, 500)\n", + "\n", + "initial_condition = tp.conditions.PINNCondition(model, initial_sampler, initial_residual)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def initial_residual_v(x, t):\n", + " #x *= 50.0\n", + " #x_t = tp.utils.grad(x, t)\n", + " return x # x_t\n", + "\n", + "initial_condition_v = tp.conditions.PINNCondition(model, initial_sampler, initial_residual_v)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [1]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 501 \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "501 Trainable params\n", + "0 Non-trainable params\n", + "501 Total params\n", + "0.002 Total estimated model params size (MB)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8d27b61e25b04e89ab7e01d9fe22061b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "00e5b06b3e544f6da68bbaeef5a29174", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.001) \n", + "solver = tp.solver.Solver([ode_condition, initial_condition_v],\n", + " optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=7500,\n", + " logger=False,\n", + " checkpoint_callback=False\n", + " )\n", + "\n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'absolute error')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "D_test = 0.08\n", + "\n", + "def analytic_solution(t, D):\n", + " return torch.sqrt(g / D) * (2/(1 + torch.exp(2*torch.sqrt(D*g)*t)) - 1)\n", + " #return 1/D * (-torch.log((1+torch.exp(-2*torch.sqrt(D*g)*t))/2) - torch.sqrt(D*g)*t) + H\n", + "\n", + "plot_sampler = tp.samplers.PlotSampler(int_t, 100, data_for_other_variables={'D': D_test})\n", + "fig = tp.utils.plot(model, lambda x: x, plot_sampler)\n", + "plt.title(\"computed solution\")\n", + "\n", + "plot_sampler = tp.samplers.PlotSampler(int_t, 100, data_for_other_variables={'D': D_test})\n", + "fig = tp.utils.plot(model, lambda t,D: analytic_solution(t, D), plot_sampler)\n", + "plt.title(\"analytical solution\")\n", + "\n", + "fig = tp.utils.plot(model, lambda x,t,D: torch.abs(x - analytic_solution(t, D)), plot_sampler)\n", + "plt.title(\"absolute error\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 8e08cbcf925fec1e9c02df9bf6fa7d9587a3bc0f Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Wed, 5 Jul 2023 16:21:07 +0200 Subject: [PATCH 23/30] First version of workshop exercise Signed-off-by: Tom Freudenberg --- examples/workshop/Exercise1_1.ipynb | 430 ++++++++++++++++++++++ examples/workshop/Exercise1_2.ipynb | 203 +++++++++++ examples/workshop/Exercise1_3.ipynb | 256 +++++++++++++ examples/workshop/Exercise2_1.ipynb | 206 +++++++++++ examples/workshop/Exercise2_2.ipynb | 261 +++++++++++++ examples/workshop/Exercise3_1.ipynb | 445 +++++++++++++++++++++++ examples/workshop/Sol1_2.ipynb | 289 +++++++++++++++ examples/workshop/Sol1_3.ipynb | 387 ++++++++++++++++++++ examples/workshop/Sol2_1.ipynb | 300 +++++++++++++++ examples/workshop/Sol2_2.ipynb | 383 +++++++++++++++++++ examples/workshop/workshop_example.ipynb | 409 --------------------- 11 files changed, 3160 insertions(+), 409 deletions(-) create mode 100644 examples/workshop/Exercise1_1.ipynb create mode 100644 examples/workshop/Exercise1_2.ipynb create mode 100644 examples/workshop/Exercise1_3.ipynb create mode 100644 examples/workshop/Exercise2_1.ipynb create mode 100644 examples/workshop/Exercise2_2.ipynb create mode 100644 examples/workshop/Exercise3_1.ipynb create mode 100644 examples/workshop/Sol1_2.ipynb create mode 100644 examples/workshop/Sol1_3.ipynb create mode 100644 examples/workshop/Sol2_1.ipynb create mode 100644 examples/workshop/Sol2_2.ipynb delete mode 100644 examples/workshop/workshop_example.ipynb diff --git a/examples/workshop/Exercise1_1.ipynb b/examples/workshop/Exercise1_1.ipynb new file mode 100644 index 00000000..cd8a55f1 --- /dev/null +++ b/examples/workshop/Exercise1_1.ipynb @@ -0,0 +1,430 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 1\n", + "\n", + "#### 1.1 PyTorch Tensor Indexing\n", + "Here you can find a small overview and explanation of the tensor syntax." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A PyTorch-tensor can easily created given a Python list. Nested lists yield higher dimensional objects:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Example for a vector: tensor([1, 2, 3])\n", + "Example for a matrix: \n", + " tensor([[1, 2],\n", + " [0, 7]])\n" + ] + } + ], + "source": [ + "tensor_1 = torch.tensor([1, 2, 3]) # a vector with 3 entries\n", + "tensor_2 = torch.tensor([[1, 2], [0, 7]]) # a 2x2 matrix\n", + "print(\"Example for a vector:\", tensor_1)\n", + "print(\"Example for a matrix: \\n\", tensor_2)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instead of creating larger tensors per hand, the constructors `torch.zeros` and `torch.ones` can create tensor of a given size:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Example for a vector: tensor([0., 0., 0.])\n", + "Example for a matrix: \n", + " tensor([[1., 1.],\n", + " [1., 1.]])\n" + ] + } + ], + "source": [ + "tensor_zeros = torch.zeros(3) # # a vector with 3 zero entries\n", + "tensor_ones = torch.ones((2, 2)) # a 2x2 matrix with ones\n", + "print(\"Example for a vector:\", tensor_zeros)\n", + "print(\"Example for a matrix: \\n\", tensor_ones)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Also tensors with more than two dimensions can be created. This will be important later, when we generally use the first dimension as the size of data batches and the later dimensions for problem specific data.\n", + "\n", + "With `tensor.shape` we can see the size of a tensor and how many entries each dimension contains.\n", + "\n", + "With `tensor[index_values]` one can view and modify the entries of the tensor. Here, the *index_values* have to be smaller than the size of each dimension-1, since we start counting at index 0." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Check shape of tensor: torch.Size([3, 2, 2])\n", + "Check top left entry of the first 'matrix': tensor(0.)\n", + "Check new top left entry of the first 'matrix': tensor(1.)\n", + "Change more values\n", + "tensor([[[1., 2.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [5., 0.]]])\n", + "Indexing also works with boolean values:\n", + "tensor([[[1., 2.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [5., 0.]]])\n" + ] + } + ], + "source": [ + "test_tensor = torch.zeros((3, 2, 2)) # could be interpreted as three 2x2 matrices\n", + "# Of course, more complex tensors could be created, but we use here only this simple example.\n", + "\n", + "print(\"Check shape of tensor:\", test_tensor.shape)\n", + "\n", + "print(\"Check top left entry of the first 'matrix':\", test_tensor[0, 0, 0])\n", + "test_tensor[0, 0, 0] = 1.0\n", + "print(\"Check new top left entry of the first 'matrix':\", test_tensor[0, 0, 0])\n", + "print(\"Change more values\")\n", + "test_tensor[0, 0, 1] = 2.0\n", + "test_tensor[2, 1, 0] = 5.0\n", + "print(test_tensor)\n", + "\n", + "print(\"Indexing also works with boolean values:\")\n", + "print(test_tensor[[True, False, True]])\n", + "print(\"This returned the first and last element of the first axis!\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Trying `test_tensor[3, 0, 0]` would throw an IndexError! Even if our first dimension has size 3, the index only runs from 0 to 2." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instead fo setting the value of entry by hand, we can utlize Python’s indexing and slicing notation `:`.\n", + "\n", + "Using `:` as an index at one position inside `[]` will do the assignment for all entries in the corresponding dimension." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top left is 2:\n", + "tensor([[[2., 2.],\n", + " [0., 0.]],\n", + "\n", + " [[2., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[2., 0.],\n", + " [5., 0.]]])\n", + "Bottom row has 3:\n", + "tensor([[[2., 2.],\n", + " [3., 3.]],\n", + "\n", + " [[2., 0.],\n", + " [3., 3.]],\n", + "\n", + " [[2., 0.],\n", + " [3., 3.]]])\n" + ] + } + ], + "source": [ + "test_tensor[:, 0, 0] = 2 # set the top left entry of every 'matrix' to 2\n", + "print(\"Top left is 2:\")\n", + "print(test_tensor)\n", + "\n", + "# they can also be combined:\n", + "test_tensor[:, 1, :] = 3 # set all values in the bottom row of every 'matrix' to 3\n", + "print(\"Bottom row has 3:\")\n", + "print(test_tensor)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Slicing is even more powerful. It works also with inplace math operations, assignment of tensor values (as long both sides have a **compatible shape**). And instead of running over all values, one can also start at value `k` with `k:` or only go to the value just before `k` with `:k`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top left is now:\n", + "tensor([[[3., 2.],\n", + " [3., 3.]],\n", + "\n", + " [[3., 0.],\n", + " [3., 3.]],\n", + "\n", + " [[3., 0.],\n", + " [3., 3.]]])\n", + "new values: tensor([1., 2., 3.])\n", + "Top right is now:\n", + "tensor([[[3., 1.],\n", + " [3., 3.]],\n", + "\n", + " [[3., 2.],\n", + " [3., 3.]],\n", + "\n", + " [[3., 3.],\n", + " [3., 3.]]])\n", + "Only change first two matrices:\n", + "tensor([[[-3., -1.],\n", + " [ 3., 3.]],\n", + "\n", + " [[-3., -2.],\n", + " [ 3., 3.]],\n", + "\n", + " [[ 3., 3.],\n", + " [ 3., 3.]]])\n" + ] + } + ], + "source": [ + "test_tensor[:, 0, 0] += 1 # add 1 to the top left entry of every 'matrix'\n", + "print(\"Top left is now:\")\n", + "print(test_tensor)\n", + "\n", + "new_values = torch.linspace(1, 3, 3) # three equdistant points between 1 and 3\n", + "print(\"new values:\", new_values)\n", + "test_tensor[:, 0, 1] = new_values # change top right values\n", + "print(\"Top right is now:\")\n", + "print(test_tensor)\n", + "\n", + "print(\"Only change first two matrices:\")\n", + "test_tensor[:2, 0, :] *= -1\n", + "print(test_tensor)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lastly, slicing can also be used to extract a smaller *sub-tensor* that keeps the shape of the original one:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([2, 2]) torch.Size([1, 2, 2])\n", + "The shape is different! In the first case we lost the first dimension.\n" + ] + } + ], + "source": [ + "tensor_sub_1 = test_tensor[0] # returns the first 'matrix'\n", + "tensor_sub_2 = test_tensor[:1] # returns also the first 'matrix'\n", + "# But:\n", + "print(tensor_sub_1.shape, tensor_sub_2.shape)\n", + "print(\"The shape is different! In the first case we lost the first dimension.\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Math operations can also be used between different tensors (generally they need to be of **similar shape** for this to work). If they have the same shape, most operations work entrywise: " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Add: tensor([3.0000, 2.1000, 8.0000])\n", + "Multiply: tensor([ 2.0000, 0.2000, 15.0000])\n", + "Divide: tensor([ 0.5000, 20.0000, 0.6000])\n", + "Works also with scalar values\n", + "Add: tensor([4., 5., 6.])\n", + "Multiply: tensor([2.5000, 5.0000, 7.5000])\n" + ] + } + ], + "source": [ + "tensor_1 = torch.tensor([1, 2, 3])\n", + "tensor_2 = torch.tensor([2, 0.1, 5])\n", + "print(\"Add:\", tensor_1 + tensor_2)\n", + "print(\"Multiply:\", tensor_1 * tensor_2)\n", + "print(\"Divide:\", tensor_1 / tensor_2)\n", + "print(\"Works also with scalar values\")\n", + "print(\"Add:\", 3.0 + tensor_1)\n", + "print(\"Multiply:\", 2.5 * tensor_1)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With `reshape` one can transform a given tensor into a different shape. For this to work, both starting and final shape need to store the same number elements." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Start with a matrix:\n", + "tensor([[1, 2],\n", + " [0, 5]])\n", + ".reshape(4) gives:\n", + "tensor([1, 2, 0, 5])\n", + "\n", + "Works also on batches (multidimensional data)\n", + "tensor([[[-3., -1.],\n", + " [ 3., 3.]],\n", + "\n", + " [[-3., -2.],\n", + " [ 3., 3.]],\n", + "\n", + " [[ 3., 3.],\n", + " [ 3., 3.]]])\n", + "Now a batch of 4 dim. vectors:\n", + "tensor([[-3., -1., 3., 3.],\n", + " [-3., -2., 3., 3.],\n", + " [ 3., 3., 3., 3.]])\n" + ] + } + ], + "source": [ + "tensor_1 = torch.tensor([[1, 2], [0, 5]])\n", + "# transform 2x2 matrix to 4 dim. vector:\n", + "print(\"Start with a matrix:\")\n", + "print(tensor_1)\n", + "print(\".reshape(4) gives:\")\n", + "print(tensor_1.reshape(4)) \n", + "\n", + "print(\"\\nWorks also on batches (multidimensional data)\")\n", + "print(test_tensor) \n", + "print(\"Now a batch of 4 dim. vectors:\")\n", + "print(test_tensor.reshape(3, 4))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With `.to` the tensors can be moved to different devices (e.g. to a GPU with `.to(\"cuda\")` and to the CPU with `.to(\"CPU\")`). For operations between two tensors, both have to be on the same device." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is ends our small overview. There are many more properites and functions, but the above syntax is enough for the following tasks. \n", + "\n", + "For more informations one can always check the offical [PyTorch documentation](https://pytorch.org/docs/stable/tensors.html)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/Exercise1_2.ipynb b/examples/workshop/Exercise1_2.ipynb new file mode 100644 index 00000000..dea9b424 --- /dev/null +++ b/examples/workshop/Exercise1_2.ipynb @@ -0,0 +1,203 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 1\n", + "\n", + "#### 1.2 Data driven function approximation \n", + "We want to train a neural network that approximates the function \n", + "\\begin{align}\n", + " u(t; D) &= \\frac{1}{D} \\left(\\ln{\\left( \\frac{1+e^{-2\\sqrt{Dg}t}}{2} \\right)} - \\sqrt{Dg} t \\right) + H\n", + "\\end{align}\n", + "In this example we consider values of $D \\in [0.01, 1.0]$, $t \\in [0, 3.0]$ and fix $g=9.81$, $H=50.0$.\n", + "\n", + "If a GPU is available (for example in Google Colab) we recomend to enable it beforehand." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import torch \n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 3.0\n", + "D_min, D_max = 0.01, 1.0\n", + "g, H = 9.81, 50.0\n", + "\n", + "# dataset size for training and testing (the batch size is the product of both) \n", + "N_D_train, N_t_train = 500, 50\n", + "N_D_test, N_t_test = 25, 50\n", + "\n", + "train_iterations = 5000\n", + "learning_rate = 1.e-3" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### a) Creating the Dataset\n", + "For the training of the neural network, we first need to create a fitting dataset. Create four tensors `input_training, output_training, input_testing, output_testing`. With shapes and data:\n", + "```\n", + "input_training.shape = [N_D_train, N_t_train, 2], output_training.shape = [N_D_train, N_t_train, 1] \n", + "```\n", + "```\n", + "input_training[i, k] = (D_i, t_k), output_training[i, k] = u(t_k; D_i)\n", + "```\n", + "Similar for the testing case. Here we want to sample $D$ randomly in our given interval (`torch.rand`) and use an equidistant grid for $t$ (`torch.linspace`). For the implementation of $u$, the functions `torch.exp, torch.sqrt` and `torch.log` are helpful. \n", + "\n", + "**Hint**: For inserting the $D$ values into the input-tensor, the methods `repeat_interleave` (repeats elements of a tensor) with the argument `N_t_train` and `reshape` (change the shape of a tensor) with the arguments `N_D_train, N_t_train` may be usefull." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Create and fill the tensors\n", + "input_training = ...\n", + "output_training = ...\n", + "input_testing = ...\n", + "output_testing = ...\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### b) Defining the Neural Network\n", + "In the next step, we define our neural network, which approximates the function. For this, we can utilize \n", + "PyTorch pre-implemented building blocks:\n", + "\n", + " - `torch.nn.Linear`: one single fully connected layer. Constructed with the number of inputs and outputs\n", + " features. \n", + " - `torch.nn.ReLU` and `torch.nn.Tanh`: possible activation functions.\n", + " - `torch.nn.Sequential`: sequentially evaluates the building blocks to create larger and more complex neural networks. Example: `torch.nn.Sequential(torch.nn.Linear(10, 15), torch.nn.Linear(15, 5), torch.nn.ReLU())`\n", + "\n", + "Build a network that has 2 input neurons for the values of $t, D$ and 1 output neuron for $u$, two hidden layers of size 20 and Tanh-activation in between." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: implement the neural network\n", + "model = ..." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### c) Writing the Training Loop\n", + "The last step is to create the training loop, where the neural network learns from the data.\n", + "The desired loss function and the optimizer we want to use are already pre-defined. Your task is to implement the missing steps inside the loop (e.g. evaluation of the model, computing the loss, and doing the optimization). \n", + "The example implementation on the [Pytorch page](https://pytorch.org/tutorials/beginner/pytorch_with_examples.html#pytorch-optim) is helpful for this task.\n", + "\n", + "Once you have finished the implementation, run all the cells and start the training. You can also run the below cell multiple times to further tune the neural network. At the end of the notebook, you can check the accuracy of the model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Move data to GPU\n", + "model.to(\"cuda\")\n", + "input_training = input_training.to(\"cuda\")\n", + "output_training = output_training.to(\"cuda\")\n", + "\n", + "### For the loss, we take the mean squared error and Adam for optimization.\n", + "loss_fn = torch.nn.MSELoss() \n", + "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n", + "\n", + "### Training loop\n", + "for t in range(train_iterations):\n", + " ### TODO: Model evaluation, loss computation and optimization\n", + " \n", + " model_out = ...\n", + "\n", + " loss = ...\n", + "\n", + " # optimization step ....\n", + "\n", + " ### Show current loss every 250 iterations:\n", + " if t == 0 or t % 250 == 249:\n", + " print(\"Loss at iteration %i / %i is %f\" %(t, train_iterations, loss.item()))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Here, a check of the accruarcy of the model with the training set and a plot of \n", + "### the solution for a given data set is implemented:\n", + "data_index_for_plot = 0\n", + "\n", + "### First compute error:\n", + "model.to(\"cpu\")\n", + "model_out = model(input_testing)\n", + "error = torch.abs(model_out - output_testing)\n", + "print(\"Relative error on the test data is:\", torch.max(error) / torch.max(output_testing))\n", + "\n", + "### Plot solution\n", + "import matplotlib.pyplot as plt\n", + "print(\"Showing D value:\", input_testing[data_index_for_plot, 0, 0].item())\n", + "plt.figure(0, figsize=(15, 5))\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(input_testing[data_index_for_plot, :, 1], model_out[data_index_for_plot].detach())\n", + "plt.title(\"Neural Network\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(input_testing[data_index_for_plot, :, 1], output_testing[data_index_for_plot])\n", + "plt.title(\"Reference Solution\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(input_testing[data_index_for_plot, :, 1], error[data_index_for_plot].detach())\n", + "plt.title(\"Absolute Difference\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/Exercise1_3.ipynb b/examples/workshop/Exercise1_3.ipynb new file mode 100644 index 00000000..a69b0692 --- /dev/null +++ b/examples/workshop/Exercise1_3.ipynb @@ -0,0 +1,256 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 1\n", + "\n", + "#### 1.3 Physics-informed function approximation \n", + "Previously we used a dataset to learn solutions of the ODE:\n", + "\\begin{align*}\n", + " \\partial_t^2 u(t) &= D(\\partial_t u(t))^2 - g \\\\\n", + " u(0) &= H \\\\\n", + " \\partial_t u(0) &= 0\n", + "\\end{align*}\n", + "Now, we assume that the solution is not analytically known. Therefore we have to utilize the above differential equation in the training, which leads us to physics-informed neural networks.\n", + "\n", + "For simplification of the implementation, we start with a fixed value for $D=0.02$." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch \n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 3.0\n", + "D = 0.02\n", + "g, H = 9.81, 50.0\n", + "\n", + "# number of time points \n", + "N_t = 50\n", + "\n", + "train_iterations = 5000\n", + "learning_rate = 1.e-3" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the physics-informed training, the derivatives of the neural network have to be comupted. For this, we can use `torch.autograd.grad` (automatic differentiation). With `torch.autograd.grad` not only the gradients of neural networks can be computed but also the derivatives of general tensor operations. Here a small example for $t^2$:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Derivative with autograd gives:\n", + "tensor([ 0., 2., 4., 6., 8., 10., 12., 14., 16., 18., 20.],\n", + " grad_fn=)\n", + "Analytical derivative is:\n", + "tensor([ 0., 2., 4., 6., 8., 10., 12., 14., 16., 18., 20.],\n", + " grad_fn=)\n", + "They are in agreement!\n" + ] + } + ], + "source": [ + "# Create some data points\n", + "t = torch.linspace(0, 10, 11, requires_grad=True) # we need to set requires_grad=True, or else\n", + " # PyTorch will not be able to compute derivatives\n", + "u = t**2 # compute the square of the values\n", + "# Next up, we have to take the sum over all our values to compute the derivative. This has to do \n", + "# with the implementation in PyTorch and we just have to remember to it.\n", + "# (the reason why is yet not so important)\n", + "u_sum = sum(u)\n", + "# Now we can call torch.autograd.grad:\n", + "u_t = torch.autograd.grad(u_sum, t, create_graph=True) # create_graph=True has to be set, so one can \n", + " # later compute derivatives of higher order\n", + "# Autograd generally returns a tuple with multiple values, here we only need the first one:\n", + "print(\"Derivative with autograd gives:\")\n", + "print(u_t[0])\n", + "print(\"Analytical derivative is:\")\n", + "print(2*t)\n", + "print(\"They are in agreement!\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### a) Working with `torch.autograd.grad`\n", + "Verify, with the help of `torch.autograd.grad`, that the previously given function\n", + "\\begin{align*}\n", + " u(t; D) &= \\frac{1}{D} \\left(\\ln{\\left( \\frac{1+e^{-2\\sqrt{Dg}t}}{2} \\right)} - \\sqrt{Dg} t \\right) + H\n", + "\\end{align*}\n", + "really solves the above ODE (e.g. numerically compute the derivatives and insert them into the ODE).\n", + "\n", + "**Hint** : `torch.sqrt` only works for tensor-objects, you habe to either transform $D, g$ into tensors or import the `math` package for the root computation. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: verify ODE solution with torch.autograd.grad" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the following cell, the time grid, a tensor for the initial time point and the neural network are given:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "t = torch.linspace(t_min, t_max, N_t, requires_grad=True).reshape(N_t, 1)\n", + "t_zero = torch.tensor([0.0], requires_grad=True)\n", + "\n", + "model = torch.nn.Sequential(\n", + " torch.nn.Linear(1, 20), torch.nn.Tanh(), \n", + " torch.nn.Linear(20, 20), torch.nn.Tanh(), \n", + " torch.nn.Linear(20, 1)\n", + ") " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### b) Implementing the physics-informed Loss\n", + "Use `torch.autograd.grad` to complete the training loop, by implementing the loss for the differential equation and both initial conditions.\n", + "\n", + "Each condition needs it own loss function, which are already prepared at the top of the cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model.to(\"cuda\")\n", + "t = t.to(\"cuda\")\n", + "t_zero = t_zero.to(\"cuda\")\n", + "\n", + "### For the loss, we take the mean squared error and Adam for optimization.\n", + "loss_fn_ode = torch.nn.MSELoss() \n", + "loss_fn_initial_position = torch.nn.MSELoss() \n", + "loss_fn_initial_speed = torch.nn.MSELoss() \n", + "\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n", + "\n", + "### Training loop\n", + "for k in range(train_iterations):\n", + " ### TODO: implement loss computation of all equations\n", + " ### Loss for the differential equation: u_tt = D*(u_t)^2 - g\n", + " u = ...\n", + " u_t = ...\n", + "\n", + " loss_ode = loss_fn_ode(..., ...)\n", + "\n", + " ### Loss for initial condition: u(0) = H\n", + " u_zero = ...\n", + " loss_initial_position = loss_fn_initial_position(..., ...)\n", + "\n", + " ### Loss for the initial velocity: u_t(0) = 0\n", + " \n", + " loss_initial_speed = loss_fn_initial_speed(..., ...)\n", + "\n", + " ### Add all loss terms\n", + " total_loss = loss_ode + loss_initial_position + loss_initial_speed\n", + "\n", + " ### Show current loss every 250 iterations:\n", + " if k % 250 == 0 or k == train_iterations - 1:\n", + " print(\"Loss at iteration %i / %i is %f\" %(k, train_iterations, total_loss.item()))\n", + "\n", + " ### Optimization step\n", + " optimizer.zero_grad()\n", + " total_loss.backward()\n", + " optimizer.step()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "### Here, a check of the accruarcy of the model:\n", + "t_plot = torch.linspace(t_min, t_max, 1000).reshape(-1, 1)\n", + "\n", + "### First compute error:\n", + "model.to(\"cpu\")\n", + "model_out = model(t_plot)\n", + "\n", + "sqrt_term = math.sqrt(D * g)\n", + "real_out = H - 1/D * (torch.log((1 + torch.exp(-2*sqrt_term*t_plot))/2.0) + sqrt_term*t_plot)\n", + "\n", + "### Plot solution\n", + "import matplotlib.pyplot as plt\n", + "plt.figure(0, figsize=(15, 5))\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(t_plot, model_out.detach())\n", + "plt.title(\"Neural Network\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(t_plot, real_out)\n", + "plt.title(\"Reference Solution\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(t_plot, torch.abs(real_out - model_out).detach())\n", + "plt.title(\"Absolute Difference\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/Exercise2_1.ipynb b/examples/workshop/Exercise2_1.ipynb new file mode 100644 index 00000000..df6fbaa3 --- /dev/null +++ b/examples/workshop/Exercise2_1.ipynb @@ -0,0 +1,206 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 2\n", + "\n", + "#### 2.1 Solving a ODE with TorchPhysics\n", + "Use TorchPhysics to solve the ODE for falling with a parachute:\n", + "\\begin{align*}\n", + " \\partial_t^2 u(t) &= D(\\partial_t u(t))^2 - g \\\\\n", + " u(0) &= H \\\\\n", + " \\partial_t u(0) &= 0\n", + "\\end{align*}\n", + "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell. Since the installation can take around 2 minutes and has to be redone if you switch to the GPU later." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UsageError: Line magic function `%` not found.\n" + ] + } + ], + "source": [ + "!pip install torchphysics\n", + "\n", + "# This will give some error messages, because some package on Google colab use newer versions than we need.\n", + "# You can ignore the errors, since we dont need the mentioned packages.\n", + "# Also, TorchPhysics will only be installed for this session, once you close the notebook it will\n", + "# be automatically deleted and everything resets to default." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl\n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 3.0\n", + "D = 0.02\n", + "g, H = 9.81, 50.0\n", + "\n", + "# number of time points \n", + "N_t = 50\n", + "N_initial = 1\n", + "\n", + "train_iterations = 5000\n", + "learning_rate = 1.e-3" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the [lecture example](https://github.com/TomF98/torchphysics/tree/main/examples) gives a good guide for working with TorchPhysics." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Implement the spaces\n", + "\n", + "\n", + "### TODO: Define the time interval \n", + "int_t = ...\n", + "\n", + "### TODO: Create sampler for points inside and at the left boundary\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Create the neural network\n", + "model = ..." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the ODE:\n", + "def ode_residual(u, t):\n", + " pass\n", + "\n", + "ode_condition = ..." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the initial position:\n", + "def position_residual(u):\n", + " pass\n", + "\n", + "initial_position_condition = ..." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the initial velocity:\n", + "def velocity_residual(u, t):\n", + " pass\n", + "\n", + "initial_velocity_condition = ..." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Syntax for the training is already implemented:\n", + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate) \n", + "solver = tp.solver.Solver([ode_condition, initial_position_condition, initial_velocity_condition],\n", + " optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus=1, # or None on a CPU\n", + " benchmark=True,\n", + " max_steps=train_iterations,\n", + " logger=False, \n", + " enable_checkpointing=False\n", + " )\n", + "\n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Here, plot the solution and the error:\n", + "import matplotlib.pyplot as plt\n", + "import math \n", + "\n", + "def analytic_solution(t):\n", + " return 1/D * (-torch.log((1+torch.exp(-2*math.sqrt(D*g)*t))/2) - math.sqrt(D*g)*t) + H\n", + "\n", + "plot_sampler = tp.samplers.PlotSampler(int_t, 1000)\n", + "fig = tp.utils.plot(model, lambda u: u, plot_sampler)\n", + "plt.title(\"computed solution\")\n", + "\n", + "fig = tp.utils.plot(model, lambda t: analytic_solution(t), plot_sampler)\n", + "plt.title(\"analytical solution\")\n", + "\n", + "fig = tp.utils.plot(model, lambda u,t: torch.abs(u - analytic_solution(t)), plot_sampler)\n", + "plt.title(\"absolute error\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/Exercise2_2.ipynb b/examples/workshop/Exercise2_2.ipynb new file mode 100644 index 00000000..af0e2b20 --- /dev/null +++ b/examples/workshop/Exercise2_2.ipynb @@ -0,0 +1,261 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 2\n", + "\n", + "#### 2.2 Solving a PDE with TorchPhysics\n", + "Use TorchPhysics to solve the following heat equation:\n", + "\n", + "\\begin{align*}\n", + "{\\partial_t} u(x,t) &= \\Delta_x u(x,t) &&\\text{ on } \\Omega\\times I, \\\\\n", + "u(x, t) &= u_0 &&\\text{ on } \\Omega\\times \\{0\\},\\\\\n", + "u(x,t) &= h(t) &&\\text{ at } \\partial\\Omega_{heater}\\times I, \\\\\n", + "\\nabla_x u(x, t) \\cdot \\overset{\\rightarrow}{n}(x) &= 0 &&\\text{ at } (\\partial \\Omega \\setminus \\partial\\Omega_{heater}) \\times I.\n", + "\\end{align*}\n", + "\n", + "The above system describes an isolated room $\\Omega$, with a \\\\\n", + "heater at the wall $\\partial\\Omega_{Heater} = \\{(x, y) | 1\\leq x\\leq 3, y=4\\}$. We set $I=[0, 20]$, $D=1$, the initial temperature to $u_0 = 16$\\,\\degree C and the temperature of the heater is defined below.\n", + "\n", + "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell. Since the installation can take around 2 minutes and has to be redone if you switch to the GPU later." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install torchphysics" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 20.0\n", + "width, height = 5.0, 4.0\n", + "D = 1.0\n", + "u_0 = 16 # initial temperature\n", + "u_heater_max = 40 # maximal temperature of the heater\n", + "t_heater_max = 5 # time at which the heater reaches its maximal temperature\n", + "\n", + "# Heater temperature function\n", + "def h(t):\n", + " ht = u_0 + (u_heater_max - u_0) / t_heater_max * t\n", + " ht[t>t_heater_max] = u_heater_max\n", + " return ht\n", + "\n", + "# Visualize h(t)\n", + "t = torch.linspace(0, 20, 200)\n", + "plt.plot(t, h(t))\n", + "plt.grid()\n", + "plt.title(\"temperature of the heater over time\")\n", + "\n", + "# Number of time points \n", + "N_pde = 15000\n", + "N_initial = 5000\n", + "N_boundary = 5000\n", + "\n", + "# Training parameters\n", + "train_iterations = 5000\n", + "learning_rate = 1.e-3" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We would recommend trying implementing the following steps by yourself (and/or together with your colleagues). \n", + "\n", + "But if you need more guidance for TorchPhysics, a heat equation example is shown in this [notebook](https://github.com/TomF98/torchphysics/blob/main/examples/pinn/heat-equation.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Implement the spaces\n", + "\n", + "\n", + "### TODO: Define the domain omega and time interval \n", + "Omega = ...\n", + "I = ...\n", + "\n", + "### TODO: Create sampler for inside Omega x I, for the initial condition in Omega x {0} and on the \n", + "### boundary \\partial Omega x I\n", + "pde_sampler = ...\n", + "initial_sampler = ...\n", + "boundary_sampler = ..." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# One can check if the points are sampled in the correct way:\n", + "plot = tp.utils.scatter(Omega.space*I.space, pde_sampler, initial_sampler, boundary_sampler)\n", + "# Some times the perspective is somewhat strang in the plot, but generally one should see:\n", + "# - blue = points inside the domain Omega x I\n", + "# - orange = points at the bottom, for Omega x {0}\n", + "# - green = points at sides, for \\partial Omega x I " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Create the neural network with 3 hidden layers and 50 neurons each.\n", + "model = ..." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the PDE:\n", + "# Use tp.utils.laplacian and tp.utils.grad to compute all needed derivatives\n", + "def pde_residual():\n", + " pass\n", + "\n", + "pde_condition = ..." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the initial temperature:\n", + "def initial_residual():\n", + " pass\n", + "\n", + "initial_condition = ..." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the boundary conditions:\n", + "### Already implemented is a filltering, to determine on what part the points are\n", + "### on the boundary, and the normal vector computation.\n", + "### For the normal derivative use: tp.utils.normal_derivative\n", + "def boundary_residual(u, t, x):\n", + " # Create boolean tensor indicating which points x belong to the dirichlet condition (heater location)\n", + " heater_location = (x[:, 0] >= 1) & (x[:, 0] <= 3) & (x[:, 1] >= 3.99) \n", + " # Normal vectors of the domain Omega\n", + " normal_vectors = Omega.boundary.normal(x)\n", + "\n", + " pass\n", + "\n", + "boundary_condition = ..." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Start the training\n", + "training_conditions = [pde_condition, initial_condition, boundary_condition]\n", + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate)\n", + "solver = tp.solver.Solver(train_conditions=training_conditions, optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", + " max_steps=train_iterations, # number of training steps\n", + " logger=False,\n", + " benchmark=True, \n", + " enable_checkpointing=False)\n", + "\n", + "trainer.fit(solver) # run the training loop" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot the solution at some point in time\n", + "time_point = 2.0\n", + "\n", + "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=1000, \n", + " data_for_other_variables={'t':time_point}) # <- input that is fixed for the plot\n", + "fig = tp.utils.plot(model=model, plot_function=lambda u : u, point_sampler=plot_sampler, angle=[30, 220])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# We can also animate the solution over time\n", + "anim_sampler = tp.samplers.AnimationSampler(Omega, I, 200, n_points=1000)\n", + "fig, anim = tp.utils.animate(model, lambda u: u, anim_sampler, ani_speed=10, angle=[30, 220])\n", + "anim.save('heat-eq.gif')\n", + "# On Google colab you have at the left side a tab with a folder. There you should find the gif and watch it." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/Exercise3_1.ipynb b/examples/workshop/Exercise3_1.ipynb new file mode 100644 index 00000000..d20bd690 --- /dev/null +++ b/examples/workshop/Exercise3_1.ipynb @@ -0,0 +1,445 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 3\n", + "\n", + "#### 3.1 Learning the Solution Operator\n", + "Use TorchPhysics and DeepONets to solve the ODE with time dependent $D(t)$:\n", + "\n", + "\\begin{align*}\n", + " \\partial_t^2 u(t) &= D(t)(\\partial_t u(t))^2 - g \\\\\n", + " u(0) &= H \\\\\n", + " \\partial_t u(0) &= 0\n", + "\\end{align*}\n", + "\n", + "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell. Since the installation can take around 2 minutes and has to be redone if you switch to the GPU later." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install torchphysics" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl\n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 3.0\n", + "g, H = 9.81, 50.0\n", + "D_min, D_max = 0.005, 5.0\n", + "# Size of the data set\n", + "data_batch = 12000\n", + "\n", + "# Number of time points for discretization of D and training\n", + "N_t = 60\n", + "\n", + "# Training parameters\n", + "train_iterations = 7500\n", + "learning_rate = 5.e-4" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Function that uses backward Euler to create the dataset (you dont have to understand this cell):\n", + "def data_create_fn(N_t, data_batch, start_height):\n", + " # Time grid (Trunk input)\n", + " t = torch.linspace(0, 3.0, 60)\n", + " dt = t[1] - t[0]\n", + " # Tensors for Branch input and expected output\n", + " D_fn = torch.zeros((data_batch, len(t), 1))\n", + " u = torch.zeros((data_batch, len(t), 1))\n", + " v = torch.zeros((data_batch, len(t), 1))\n", + " \n", + " # Create different fuction types for D_fn:\n", + " # First batch are step functions:\n", + " ind = int(data_batch / 3.0)\n", + " random_steps = D_min + (D_max - D_min) * torch.rand((ind, 6, 1))\n", + " D_fn[:ind, :] = random_steps.repeat_interleave(int(N_t/6), dim=1)\n", + " # Second batch are sinus functions:\n", + " random_fre_amp = D_min + (D_max - D_min) * torch.rand((ind, 1, 2))\n", + " random_fre_amp = random_fre_amp.repeat_interleave(N_t, dim=1)\n", + " sin_fn = random_fre_amp[:, :, 1]/2.0 * (D_min + 1 + torch.sin(random_fre_amp[:, :, 0] * t))\n", + " D_fn[ind:2*ind, :] = sin_fn.unsqueeze(-1)\n", + " # Last batch is exp functions:\n", + " missing_idx = data_batch - 2*ind\n", + " random_start_sloope = (D_max - D_min) * torch.rand((missing_idx, 1, 2))\n", + " random_start_sloope = random_start_sloope.repeat_interleave(N_t, dim=1)\n", + " exp_fn = D_min + random_start_sloope[:, :, 1] * torch.exp(-random_start_sloope[:, :, 0] * t)\n", + " D_fn[2*ind:, :] = exp_fn.unsqueeze(-1)\n", + " # flip some exp functions around t=1.5:\n", + " D_fn[int(2*ind + missing_idx/2.0):, :] = torch.flip(D_fn[int(2*ind + missing_idx/2.0):, :, :], dims=(1,))\n", + " \n", + " # Do time stepping to compute solution\n", + " u[:, 0] = start_height\n", + " for i in range(len(t)-1):\n", + " v[:, i+1] = 1/(2*dt*D_fn[:, i+1]) - torch.sqrt(1/(2*dt*D_fn[:, i+1])**2 - (v[:, i] - dt*g)/(dt*D_fn[:, i+1]))\n", + " u[:, i+1] = u[:, i] + dt * v[:, i+1]\n", + "\n", + " return t.reshape(-1, 1), u, D_fn[:, ::2, :]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Here we create the data\n", + "t_tensor, u_tensor, D_tensor = data_create_fn(N_t, data_batch, H)\n", + "\n", + "# Show an example plot\n", + "import matplotlib.pyplot as plt\n", + "plt.figure(figsize=(16, 4))\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(t_tensor[::2], D_tensor[0])\n", + "plt.plot(t_tensor[::2], D_tensor[4000])\n", + "plt.plot(t_tensor[::2], D_tensor[8000])\n", + "plt.ylabel(\"D\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(t_tensor, u_tensor[0])\n", + "plt.plot(t_tensor, u_tensor[4000])\n", + "plt.plot(t_tensor, u_tensor[8000])\n", + "plt.ylabel(\"u\")\n", + "plt.xlabel(\"t\")\n", + "plt.title(\"Solution for corresponding D\")\n", + "plt.grid()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### a) Shuffle and Split Data \n", + "The above data is created in ordered way (e.g. first 4000 entries belong to step functions). Randomly permute the tensors of $u$ and $D$ along the batch dimension and then split both tensors into a training set consisting of 80% of the data and a testing set with the remaining 20%.\n", + "\n", + "**Hint** for the shuffling `torch.randperm` may be useful." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Permute data of u, D and split them into two sets (training and testing)\n", + "\n", + "# permute ....\n", + "permutation = torch.randperm(len(D_tensor))\n", + "u_tensor = u_tensor[permutation]\n", + "D_tensor = D_tensor[permutation]\n", + "\n", + "# Then split\n", + "u_tensor_train = u_tensor[:10000]\n", + "D_tensor_train = D_tensor[:10000]\n", + "u_tensor_test = u_tensor[10000:]\n", + "D_tensor_test = D_tensor[10000:]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we start with the TorchPhysics part" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Spaces \n", + "T = tp.spaces.R1('t') # input variable\n", + "U = tp.spaces.R1('u') # output variable\n", + "D = tp.spaces.R1('D') # function output space name\n", + "\n", + "# Domain\n", + "int_x = tp.domains.Interval(T, t_min, t_max)\n", + "\n", + "# Space that collects the Branch functions\n", + "Fn_space = tp.spaces.FunctionSpace(int_x, D)\n", + "discretization_sampler = tp.samplers.DataSampler(tp.spaces.Points(t_tensor[::2], T))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "output_neurons = 25\n", + "branch_net = tp.models.FCBranchNet(Fn_space, discretization_sampler, (30,30,30))\n", + "trunk_net = tp.models.FCTrunkNet(T, (30,30,30))\n", + "deepOnet = tp.models.DeepONet(trunk_net, branch_net, U, output_neurons)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "branch_batch_size = len(u_tensor_train)\n", + "trunk_batch_size = len(t_tensor)\n", + "dataloader = tp.utils.DeepONetDataLoader(D_tensor_train, t_tensor, u_tensor_train, D, T, U,\n", + " branch_batch_size, trunk_batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "data_condition = tp.conditions.DeepONetDataCondition(deepOnet, dataloader, 2, root=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 6.3 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "6.3 K Trainable params\n", + "0 Non-trainable params\n", + "6.3 K Total params\n", + "0.025 Total estimated model params size (MB)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "be785d8d4f4c40518e8c6063cedbaf07", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "695ac09798aa4c5ca29d01b3c0759683", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate) \n", + "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", + "\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=train_iterations,\n", + " logger=False\n", + " )\n", + "\n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max. absolute error on test set is: 1.6479072570800781\n", + "Relative error is: 0.032958145141601565\n" + ] + } + ], + "source": [ + "# Check error on test set:\n", + "u_model = deepOnet(tp.spaces.Points(t_tensor, T), D_tensor_test).as_tensor\n", + "error = torch.abs(u_model - u_tensor_test)\n", + "print(\"Max. absolute error on test set is:\", torch.max(error).item())\n", + "print(\"Relative error is:\", torch.max(error).item() / 50.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot a solution from the test set:\n", + "plot_idx = 786\n", + "\n", + "u_model = deepOnet(tp.spaces.Points(t_tensor, T), D_tensor_test[plot_idx]).as_tensor[0]\n", + "ref_solution = u_tensor_test[plot_idx]\n", + "\n", + "plt.figure(0, figsize=(14, 4))\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(t_tensor[::2], D_tensor_test[plot_idx])\n", + "plt.title(\"D(t)\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(t_tensor, u_model.detach())\n", + "plt.plot(t_tensor, ref_solution)\n", + "plt.title(\"Solution\")\n", + "plt.legend([\"DeepONet\", \"Real Solution\"])\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(t_tensor, torch.abs(ref_solution - u_model.detach()))\n", + "plt.title(\"Absolute Difference\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+gAAAEYCAYAAADPrtzUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABp80lEQVR4nO3dd3hUZfrG8e8zkx5CQiCEEnqVXkKzEXsva8GCCgpiL+u6li3urj9dV3ddu6uIKIgNu2tdC1GU3nvvvZcQQtr7+2MGjTGBBJKcmeT+XFcuMzPnzNxzMM/Mc8573mPOOURERERERETEWz6vA4iIiIiIiIiIGnQRERERERGRkKAGXURERERERCQEqEEXERERERERCQFq0EVERERERERCgBp0ERERERERkRCgBl1Clpn91czGeJ3jaJlZczNzZhbhdRYRqXxmlmpm35vZXjN73Os8Vc3MVpnZqUe4blMzyzIzf0XnEpGqZWavmtlDFfycg83sh4p8zqNRvGYVr/8W8IqZ7TSzKV7nlfCgBl1+EvxStcXM4ovcN9TMMj2MVSIzywg2vc8Xu/8HMxtcxudwZta6UgKKSFgL1sP9wS9em4JfNGuVcfVhwDagtnPud5UYs9KYWZqZvWdm28xst5nNK2ttLefr/KKZd86tcc7Vcs4VVPRriUjlMLPMYAMa7XWWoo62mQ+uXxD8HMgys5XBZrvtwWVKqFnF6//xwGlAmnOu99G8H6k51KBLcX7gjsp+kQo6mrwPuNrMmlfAc1UKHTUXCWvnOedqAd2A7sD9ZVyvGbDAOefK+4IhVDNeA9YSeC91gauBzZ4mEpGQE/wOdgLggPO9TVMpJgY/BxKBU4H9wHQz61TK8sXrfzNglXNuX3lfOIQ+D6SKqUGX4v4J3G1mSSU9aGbtzewrM9thZovNbECRxzLNbGiR27/Ycxk8Yn2LmS0Flgbve8rM1prZHjObbmYnlCPrLuBV4C+lLWBm15nZwuCe3S/NrFnw/u+Di8wO7hW9zMy+M7OLg48fF8x7TvD2KWY2K/i7z8z+ZGargyMORptZYvCxg8PZh5jZGuDbEjJdHDxqVFpxF5EQ4pzbBHxJoFEHwMz6mtkEM9tlZrPNLCN4/6vAIOCeYG05NVgz7jOz5Wa23czGmllycPkSa0ZptSv4mDOzG81safD1nzMzK/L49cF195rZAjPrEby/UfCo+NbgkaDbD/G2ewGvOuf2OefynXMznXOfF3mN881sfvD1M83smJKexIoNcbXA6Kd1wd9fA5oC/w1uq3us2ClBwcwfBz9zlpnZ9UWe66/BbTk6+F7nm1n6Id6TiFS8a4BJBL6PDSrh8XrB7417g9+zDn4PMzN7Ivg9ao+ZzT34vcjMEoN/11uD37X+ZGa/6lmK14vgfZkWGP15DPAC0C9YX3YFH482s3+Z2Roz22xmL5hZ7OHepHOuwDm33Dl3M/Ad8NfiGUqo/zcAI4pk+FtwnXPNbFawfk4wsy5F8q8ys3vNbA6wL/i8JX7eFHm//2dmPwa38f/MrF6Rx48vsu5aC46EOtLtIFVDDboUNw3IBO4u/oAFhr5/BbwB1AcuB543sw7leP4LgT7AwXWmEvjSmxx83nfMLKYcz/cwcLGZtSsh7wXAH4CLgBRgPPAmgHPuxOBiXYNDk94mUHAzgvf3B1YAJxa5/V3w98HBn5OAlkAt4NliL98fOAY4o1ima4FHgVOdc/PK8T5FxCNmlgacBSwL3m4MfAo8RKB23Q28Z2YpzrnBwOvAY8Ha8jVwG4Ha1x9oBOwEniv2Mj/VjEPVriLOJdBEdwEGEKw1ZnYpgS+O1wC1CRzR2h78cvtfYDbQGDgFuNPMzqBkk4DnzOxyM2tabHu0Dea5M5jvMwJNdlQpz1Ui59zVwBqCIxWcc4+VsNhbwDoC2+0S4O9mdnKRx88PLpMEfMyva7GIVK5rCNS81wnUr9Rijw8E/g+oB8wKLgdwOoHvWG0JHJ0eAGwPPvZM8L6WBGrjNcC15QnlnFsI3EjwCLhzLin40D+Cr9kNaE2gHj5QnucG3icwaqD4aw7ml/X/xWIZ/mJm3YGRwA0ERie9CHxsvzw94ArgHAJ1LZVSPm+KLH8lge1TH4gKLkNwZ8jnBLZnSvA9z6rA7SCVRA26lOQB4LZif/wQ+EK4yjn3ysEjKsB7wKXleO5HnHM7nHP7AZxzY5xz24PP9zgQDfyq2S5N8MjWC8CDJTx8Y/D1Fjrn8oG/A92syJGoYr4j8EEAgQ+NR4rcLtqgDwT+7Zxb4ZzLIjDs9XL75VCkvwaPPO0vct+dwO+BDOfcsrK+RxHxzIdmtpfAUO8t/Dxa5yrgM+fcZ865QufcVwR2bp5dyvPcCPzRObfOOXeAQAN9ySFqRllq1z+cc7ucc2uAcfx8dH8ogS+HU13AMufcagLNfIpz7kHnXK5zbgXwEoEdrSW5lMCOgT8DK4NHe3oFH7sM+NQ595VzLg/4FxALHFv6piw/M2sCHAfc65zLcc7NInA06poii/0Q/HcoIDAsv2tFZhCR0pnZ8QSGcI91zk0HlhNoFov61Dn3fbD2/ZHA0eQmQB6QALQHLFjvNlpgsrXLgfudc3udc6uAxwmcZnO0eY3AOeK/DX4X3UugvpZWB0uzgUCzfCSGAS865yYHj8qPAg4AfYss87Rzbm3w86AsnzevOOeWBJcfy8+fB1cCXzvn3nTO5QW/b8+qwO0glUQNuvxK8MjuJ8B9xR5qBvQJDpPZFRwuNBBoUI6nX1v0hpndbYGhmLuDz5dIYC9reTxKYK9t8S9mzYCnimTdARiBvYQlmQi0De797QaMBpoEhwr1Bg4Oi28ErC6y3moggsBezoN+8T6Dfg8855xbV8b3JSLeutA5l0BgZE17fq5NzYBLi9XC44GGpTxPM+CDIssuBAoovWaUpXZtKvJ7NoGRPABNCHxJLilDo2KZ/1Asw0+cczudc/c55zoGl5lFYIeFUawGOucKg/lLq61HqhFw8MvjQas59HaIMZ23KVJVBgH/c85tC95+g18Pc/+ptgUPauwAGjnnviUw4uU5YIuZDTez2gTqbCS//p5VEfUlBYgjcA75wTr4RfD+8mhM4H0ciWbA74rV4iYE6t1BxT8PDvd5U97Pg4raDlJJ9CEmpfkLMIPAXsuD1gLfOedOK2WdfQT+4A8qqXH/adIkC5xvfg+BoZbznXOFZraTwBfRMnPObTezJwkMoSpqLfCwc+71X69V4vNkm9l0ApPkzXPO5ZrZBOAuYHmRD6ANBArmQU2BfAITKKUdfLoSXuJ04Asz2+Sce68smUTEe86574LnFv6LwFD1tcBrzrnrD7VeEWuB65xzPxZ/wH6e5NIVW77MtauE12pVyv0rnXNtyvuEzrltZvYvAl+8kwnUwM4HHw827U2A9SWsfrjPhUNNpLcBSDazhCJNetNSXkdEqlDwfOUBgN/MDjaI0UCSmXV1zs0O3tekyDq1+LmG4Jx7GnjazOoTOPL7ewIjjPIITrYWXLW0v/uDE6/FAXuCvxetMcXryzYCk7x1dM4dTR35DYERRkfiYH1/+BDLFP88KM/nTfHXKmnm+IraDlJJdARdShQcgv02UHQSoU8IHGG+2swigz+97OfJgWYBF5lZnAUuXzbkMC+TQKCx3QpEmNkDBM6ZPBL/JjC8suhERS8A95tZR/hp0pGiw/E3Ezi/qajvgFv5eTh7ZrHbEDj38rdm1iL4YfN34O3gUNRDmQ+cSeC8zuo406lIdfYkcFpwpM4Y4DwzO8PM/GYWY4HJz9JKWfcF4GH7eXKklOB55qU5XO06lBEEJvrsaQGtg687BdhrgcmHYoO5OxUZtv4LZvZo8PEIM0sAbgKWOee2E/gifY4FJs+MBH5HYIjmhBKeahZwtpklm1kDAqf6FFVSHQbAObc2+JyPBLdxFwKfK2PKuC1EpPJcSGAkUAcCow67EfgONp5fnoZytgUmKosicCBlknNubfD7Y59gDdkH5ACFwdNVxhKomQnB+nUXJfzdO+e2EmjcrwrWtOv45Q7KzUBa8LUPjvZ5CXgiuFMAM2tspc/F8ZPg87cws2cIjKr6W1k2UgleAm4Mvnczs3gzOydYZ0tS3s+bol4HTjWzAcFaXtfMuh3NdpCqoQZdDuVB4KdrogePYJxO4ByVDQSG1DxKYI8pwBNALoGCOIqfJwIpzZcEhtQsITB8KYeSh4YflnNuD/AYRc4Jcs59EMz3lpntAeYRmOjpoL8Co4LDew7ORv8dgR0H35dyGwKTe7wWvG9lMPdtZcw5m8C5/C+Z2VmHW15EQkPwi+Bo4IFg43hwIretBOrW7yn9M/UpAhOY/c8C57RPIjBZZmmvdbjadaic7xCYPPMNYC/wIZAc/NJ7LoEv0SsJHEEZQeC0opLEAR8QuFrGCgJHs84PvsZiAudFPhN8nvMITPSWW8LzvEZgYrpVwP8I7Pgt6hHgT8E6/KvJSQlMltScwGfOB8BfXGDiPRHx1iAC5z6vcc5tOvhDYNj6wCKnmrxBYFTmDqAngdoBgQMyLxGYNHM1gQni/hl87DYCTfsK4Ifgc4wsJcf1BOrvdqAjv9xR+C2BgyObzOzgKMh7CUz4OSlYX7/m0HMf9TOzLAJH6DODuXs55+YeYp1SOeemBTM/S+C9LyMw8XBpy5f386boumsInKv+OwLbfxY/z9NR3u0gVchc+S/TKiIiIiIiIiIVTEfQRUREREREREKAGnQRERERERGREKAGXURERERERCQEqEEXERERERERCQFVeh30evXquebNm5d7vX379hEfH3/4BUOIMledcMwdjpkhPHMfaebp06dvc86lVEKkMlPNDH3hmDscM0N45g7HzHBkuUOhZsKR1c2a9O/ktXDMDOGZOxwzQ3jmrvDvms65Kvvp2bOnOxLjxo07ovW8pMxVJxxzh2Nm58Iz95FmBqa5KqyPJf2oZoa+cMwdjpmdC8/c4ZjZuSPLHQo10x1h3axJ/05eC8fMzoVn7nDM7Fx45q7o75oa4i4iIiIiIiISAtSgi4iIiIiIiIQANegiIiIiIiIiIUANuoiIiIiIiEgIUIMuIiIiIiIiEgLKdJk1M1sF7AUKgHznXLqZJQNvA82BVcAA59zOyokpIhJeVDdFREREpLzKcwT9JOdcN+dcevD2fcA3zrk2wDfB2yIi8jPVTREREREpszIdQS/FBUBG8PdRQCZw71Hm+YW9OXl8Omcjm7bkk7xuFykJ0dSNjyYqQiPzRSQsVXrdzFy8hR/W57F71noifD78PiMqwoiLiiAhJoLaMZEkxESQEBOJ32cV+dIiIiIiIS83v5Dvl2wluVYUberXIiEm0utIv1DWBt0B/zMzB7zonBsOpDrnNgYf3wSkVnS41duzue/9uQA8OePHn+6vGx9Fo6RYGiXF0DgpjsZ1YmmaHEeLenE0SY4jOsJf0VFERMrriOqmmQ0DhgGkpqaSmZlZrhd9dMp+Fu4ohLmzDrmcAQlRkBjtIzHaSIo26sYYKXFGSqyP+nFGYrThs6pp4rOyssr9XkNBOOYOx8wQnrnDMTOEb24RkcPZk5PHzWNm8MOybT/d1zgplraptTivayMu6pHmYbqAsjboxzvn1ptZfeArM1tU9EHnnAt+Cf2Vo/myWVDoeLx/LBt3ZZPnj2H3AcfuA46dOYVsz8li7qo9jMtx5BYUeT0gOcZoEG80quUjrZaPxrV8NE7wERtRdUeLwvHDLRwzQ3jmDsfMEJ65Pcx8RHUz2MgPB0hPT3cZGRnletGOPQ8wbvyP9OzVm/wCR15BIXkFhWTnFrA3J489Ofnszclnd3YuW7MOsHXvAbbsPcCyPQf4cUMOrkiimEgfrevXom1qAu1SE2jbIIEODWuTWjum/FvjMDIzMynvew0F4Zg7HDNDeOYOx8wQvrlFRA5l4+79XPvKVJZtyeL/LuxEg9oxLNm8lyWb9zJr7S7ufmc2nRsn0iY1wdOcZWrQnXPrg//dYmYfAL2BzWbW0Dm30cwaAltKWfeovmzCoT8onHPszM5j9fZ9rNq+j5Xbslm1bR8rtmUxfkMWOXn5Py3bOCmWTo1r06lRIp0aJ9KxcW3qJ1T8F83DZQ5V4ZgZwjN3OGaG8MztVeajqZtHIyUhmvpxPlql1Cr3urn5hazftZ81O7JZs30fq7Zns2TzXn5cto33Z6z/abnU2tF0SUuiW5MkuqQl0q1JUsgNDxMRERE5aMGGPVz36lT2Hcjn1Wt7c3ybegCc1iEwmHHnvlxOfGwcj36xmBGD0g/1VJXusA26mcUDPufc3uDvpwMPAh8Dg4B/BP/7UWUGPUQ+kuOjSI6PonvTOr94rLDQsW7nfhYH94ws3LiH+Rv28OX8zT8t0zgplm5Nk+jRtA49mibRoVFtDZEXkaMS6nWzNFERPlrUi6dFvXgg5ReP7crOZfGmvSzYuIfZa3cxZ91uvloQqKU+g06NE+nTIpk+LerSq3kyiXFq2EVERMR7Pyzdxo1jplMrOoJ3bupH+wa1f7VMnfgobsxoxT+/XMzUVTvo1TzZg6QBZTmCngp8YIHzECOAN5xzX5jZVGCsmQ0BVgMDKi/mkfH5jKZ142haN+6nvSMQmHxuwYY9zF2/m5lrdzFz9U4+nRM4LTQ6wkePpnXo27IufVsm07VJEjGRathFpFzCtm6WJikuij4t69KnZd2f7tudncfsdbuYumoHk1fsYNSE1bw0fiU+g25Nkujftj7926XQpXEiPk1IJyIiIlVsyea9DB09leZ143nl2l40TIwtddnrjmvBqAmr+Mfni3j3xn5YFc3DU9xhG3Tn3Aqgawn3bwdOqYxQlS0hJvJXXzQ37c5h5pqdTF21k8krt/PkN0twXweOKPVqXocT26RwYtsU2jdI8OwfS0TCQ3WsmyVJjIvkxLaB2giQk1fArLW7mLBsG98t3caT3yzhia+XkBwfRUbbFE7v2ID+bVOIjdJOTxEREalc2bn53PL6DGpFRzD6ut7UP8wcOrFRfn57Wlvuf38uXy3YzOkdG1RR0l86msusVSsNEmM4q3NDzurcEAgcGZq6agcTV2znh6XbeOTzRTzy+SLqJ0RzYtsUTmlfnxPbphAfrU0oIgIQE+kPjj6qy12nt2PHvlzGL93Kd4u38u3iLbw/cz0xkT76t03hjI4NOLVDKrV17rqIiIhUggc+ms+yrVmMGdLnsM35QZf2TGPE+BU8+sUiTm5fnwh/1V/eW91lKRLjIjm1QyqnBofGb9qdw/dLt/L9kq18tWAz705fR1SEj+Na1eW0Dg04tUP9SptwTkQkHCXHR3FBt8Zc0K0x+QWFTFm5gy/mb+J/8zfz5fzNREX4OPWY+pzftTG+ghIvBCIiIiJSbu9MW8u709dxxyltOK51vTKvF+H3cc+Z7bnhtem8O30dl/duWokpS8lQ5a8YphokxjAgvQkD0puQX1DI1FU7+WrBZr5auIlxH8zljx9CnxbJnNe1EWd1auh1XBGRkBLh93Fs63oc27oefz2vI7PW7eLjWRv4ZM4GPpu7idgIOH/nHC5NT6Nnszo6lUhERESOyJLNe/nzR/Po17Iut5/Sptzrn94hlR5Nk3ji6yVc0K1xlZ+apwb9CET4ffRrVZd+rery53OPYfHmvXw2dxOfzNnAHz+YxwMfzeeYOj521F7HmZ0aEBelzSwicpDPZ8ErZ9ThT+ccw4Tl23nxixn8d84G3p62llYp8QxIb8JFPdJISYj2Oq6IiIiEiezcfG5+fQa1oiN56opu+I9gkloz4/6zj+HSFyby9tQ1DD6uRSUkLZ06x6NkZrRvUJv2DWrz21PbsGDjHj6Zs5F3J6/grrGz+fOH8zi7c0Mu6ZlG7xbJOiokIlJEhN/HiW1TKNwQTXq/4/l0zgbGTlvHI58v4p9fLub0jqlc3bc5fVuqfoqIiEjpnHP86cN5LD943vlRnH7cq3kyLevF88OybWrQw5mZ0bFRIh0bJdI7eiPxzbvy7vS1fDpnI+9MX0fT5Dgu7x0YJl+vlo4KiYgUVSs6gst6NeWyXk1ZtmUvb09dyzvT1/HZ3E20Ta3F1f2ac1H3xpqcU0RERH5l7LS1vD9jPXeeWr7zzkvTu0Uyn83dSGGhq9LLxVb9tHQ1hJnRu0Uyj13Slal/OpUnLutKw8QYHvtiMf0e+Ybb3pzJ5BXbcU4TI4mIFNe6fgJ/PKcDk+4/hccu6UJUhI8/fziPvn//hoc/XcCGXfu9jigiIiIhYsGGPTzw0XxOaFOP204u/3nnJendIpk9Ofks3ry3Qp6vrHQYogrERUXwm+5p/KZ7Gks37+X1yWt4b8Y6/jt7A+1SExhyfAvO79aImEhdG1hEpKiYSD8D0ptwac80Zq7dxas/rmLkj6t45cdVnNOlIdef0JJOjRO9jikiIiIe2ZuTx82vTycpLpInLjuy885L0rtFMgBTVu7gmIa1K+Q5y0JH0KtYm9QE/np+Ryb/4RQevbgzZnDPe3M4/tFvefLrJWzLOuB1RBGRkGMWmFju6Su68/09JzH42OZ8vWAz5z7zAwNHTGLC8m0akSQiIlLDOOe47725rN25n2ev7FGhpxGn1YmjcVIsU1buqLDnLAs16B6Jiwqca/n5HSfw+tA+dElL4smvl3LsP77ljx/MZc32bK8jioiEpMZJsfzp3A5M/MMp3H9We5ZszuLKlyZzyQsTGbdoixp1ERGRGmLUhFV8Oncj95zRjl7Nkyv8+Xu3SGbyyh1V+t1CDbrHzIzjWtdj5OBefH1Xfy7ukcY709Zx0uOZ/PbtWSyp4nMeRETCRe2YSG7o34rx95zE/13QkU27c7j21amc+8wP/G/+JjXqIiIi1di4RVt4+LOFnHpMfa4/oWWlvEbvFslsyzrAym37KuX5S6IGPYS0rl+LRy7qzPh7T+LaY5vzxbxNnP7E99zw2jQWbNjjdTwRkZAUE+nn6n7NGXd3Bo9d0oV9B/IZ9tp0LnjuRzIX64i6iIhIdfP9kq3cMGY67Rok8PiAbpU2y3rR89Crihr0EJRaO4Y/nduBCfedzO2ntGHC8u2c/fR4bn59uo6oi4iUIirCx4D0Jnx9V38eu6QL27NyGfzKVC55YSITlm/zOp6IiIhUgB+XbeP60dNonVKLMUP6kBgbWWmv1bJePPVqRalBl4A68VHcdVpbfrjnZG4/uTXfL9nGGU9+z21vzmTF1iyv44mIhKQIf6BRH3d3Bg9d2In1O/dz5UuTuWbkFI1GEhERCWMTl29nyKiptKgXz5ihfUiKi6rU1zMzejUPnIdeVdSgh4HEuEjuOr0d4+85iRv7t+LrBZs57Ynv+cMHc9myJ8freCIiISkqwsdVfZuR+fsM/nj2Mcxeu4tznhnPXW/PYt1OTcQpIiISTg42503qxDFmaB+S4yu3OT+od4tk1u/az/pd+6vk9dSgh5E68VHce2Z7vr/nJK7q05SxU9fS/5+ZPP6/xezNyfM6nohISIqJ9HP9iS35/vcnMezElnwydyMnP/4dj3y2kD2qnSIiIiEtJ6+ARz5byMARk2iQGMPr1/ep0MupHc7B89CnVtFRdDXoYSglIZq/XdCJr+/qz6kdUnnm22X0/2cmoyeuIr+g0Ot4IiIhKTEukvvPOobMuzM4r0sjho9fwUn/zOSNyWsoKNREciIiIqFmysodnPXUeF78fgWX9WrKh7ccR/2EmCrN0L5BbRJiIqpsmLsa9DDWvF48z1zRnf/eejxtU2vxwEfzOeup8WQu3uJ1NBGRkNUoKZbHB3Tl41uOp1VKLf7wwVzOeXo8E5ZpIjkREZFQsHNfLn/5aB4DXpxIfmEhrw/twyMXdaZ2TOVNCFcavy9wHvqUldur5PXUoFcDndMSefP6vgy/uid5BYUMfmUqg0ZOYalmfBcRKVXntETevqEvzw/sQdaBfK4cMZmbX5/Ohio6x0xERER+aWNWIX/8YC79/vENoyetZvCxzfnijhM5rnU9T3P1bpHM8q372JZ1oNJfK6LSX0GqhJlxescGZLSrz+iJq3jqm6Wc9dR4Bh3bnDtObePJ3iYRkVBnZpzduSEnt6/PS9+v4LnMZYxbtJVbT27N0BNaEB3h9zqiiIhItTdx+XZeGr+CbxftJypiHb/p1pjrjm9BuwYJXkcDfnke+lmdG1bqa+kIejUTFeFj6Akt+e73J3FpehNG/riSk//1He9OX0ehzrEUESlRTKSf205pw9d39efEtvX455eLOfPJ8Xy/ZKvX0URERKqtxZv2MmjkFK54aRKz1+7iwtaRTLjvZB69pEvINOcAnRolEhvpr5Lz0NWgV1PJ8VE8clFnPr7leJokx3L3O7O55IUJzFu/2+toIiIhK61OHC9enc6r1/bCOcc1I6dw25sz2bJXl7QUqWhmdqaZLTazZWZ23yGWu9jMnJmlV2U+Eak8W/bkcN97czjrqe+ZuWYnfzi7PT/edzIXto6q0hnayyoqwkePZklMUYMuR6tzWiLv3Xgs/7ykC2t2ZHP+sz/wt//O12XZREQOIaNdfb787Yn89tS2fDlvE6c8/h1jJq3WSCSRCmJmfuA54CygA3CFmXUoYbkE4A5gctUmFJHKMnZa4FLR781Yx7XHteC735/EsBNbERMZ2qeV9WqezMJNeyr9Eq1q0GsAn8+4NL0J39yVwZV9mvLqhFWc+u/v+HTORpzTl00RkZJER/i549Q2fHHnCXRunMifPpzHJS9MYPEmTcApUgF6A8uccyucc7nAW8AFJSz3f8CjgIaxiFQDH81az73vzaFHsyS+vqs/fz63A3Xio7yOVSYdGtbGOVixdV+lvo4miatBEuMieejCzlzSswl/eH8ut7wxg/5tU3jowk40SY7zOp6ISEhqmVKL14f24YOZ63no04Wc+8x4bs5ozS0ntfY6mkg4awysLXJ7HdCn6AJm1gNo4pz71Mx+X9oTmdkwYBhAamoqmZmZ5QqSlZVV7nVCQTjmDsfMEJ65QzHzrC35PDPzAG2TfAxqsZ+Vc6eystgyoZj7oK1ZhQB8Nn4auxr93EZXdGY16DVQtyZJfHzrcYyeuJrH/7eY05/4nt+d3pYWGropIlIiM+OiHmlktKvPg/+dz1PfLOXzeRu5rEUBGV6HE6mGzMwH/BsYfLhlnXPDgeEA6enpLiMjo1yvlZmZSXnXCQXhmDscM0N45g61zJNXbOc/X0+hQ6NE3ri+DwmlXGEq1HIXlZNXwJ9+/ILYlKZkZLT96f6KzlzmIe5m5jezmWb2SfD2q2a20sxmBX+6VVgqqXQRfh/XHd+Cr+7qz7Gt6vLQpwt5aFIOCzbs8TqaSLWgmlk9JcdH8eTl3Rk5OJ29Ofk8NCmH//tkAftzC7yOJhJu1gNNitxOC953UALQCcg0s1VAX+BjTRQnEn7mrd/N0FHTSKsTy6jrepfanIe6mEg/jRJjWbW9coe4l+cc9DuAhcXu+71zrlvwZ1bFxZKq0igplhGD0nnmiu5szynkvGd/4LEvFpGTpy+bIkdJNbMaO7l9Kv/77Yn0bxLByz+s5OynxzN9deXP7CpSjUwF2phZCzOLAi4HPj74oHNut3OunnOuuXOuOTAJON85N82buCJyJDbvyeGakVOoHRvJmKF9SA6T881L06JePKu2hUCDbmZpwDnAiEpNI54wM87r2oi/Hx/HRd0b83zmcs595gdmrtnpdTSRsKSaWTMkxEQyuGM0bwztQ25+IZe+MJFHPluoHZwiZeCcywduBb4ksDNzrHNuvpk9aGbne5tORCrKc+OWsWd/HqOu603DxFiv4xy15vXiWLltX6VOtF3Wc9CfBO4hMNyoqIfN7AHgG+A+59yB4ise7cQdENqTBZQmHDOTu49zUowmPaN5df4+Lnp+Ame1iOTC1pFE+c3rdKUKx20djpkhPHN7lPlJVDPLJRwzQyB3rXXz+FO68faiCF78fgX/nb6SoV2iaZkYmpeLCedtHW65wzEzVF1u59xnwGfF7nuglGUzKj2QiFSo9bv289aUtQzo1YTW9Wt5HadCNK8bz56cfHZm51XaaIDDNuhmdi6wxTk33cwyijx0P7AJiCIwMce9wIPF1z/aiTsgtCcLKE04Z84ABp+XxyOfLeTNKWtZlBXF45d2pXvTOl5HLFE4b+twE465qzqzauaRCcfM8MvcZ50K3y/Zyr3vzeHhyQe47eTW3HpSayL8oXVF0+qwrcNFOGaG8M0tIqHluXHLAKrVVU9a1IsHYOW2fZXWoJflW8NxwPnBCTreAk42szHOuY0u4ADwCoHrWUo1UTsmkkcu6sJrQ3pzIK+Qi/8zgX99uZjc/EKvo4mEOtXMGuzEtil8ceeJnN+1EU9+vZSLX5jIyko+V01ERCTUrN2Rzdipa7m8dxMaJ4X/0PaDmgcb9Mo8D/2wDbpz7n7nXFpwgo7LgW+dc1eZWUMAMzPgQmBepaUUz5zQJoXP7zyBi3qk8ey4ZVz43I8s3rTX61giIUs1UxJjI3nism48e2V3Vm3bx9lPjef1yasr9Xw1ERGRUPLst8vw+YybM6rP0XOAJnXi8BmVOpP70Yy7e93M5gJzgXrAQxUTSUJN7ZhI/nVpV4Zf3ZPNe3I475kfGP79cgp13XSR8lDNrGHO7dKIL+88kfTmdfjjB/O4fvQ0tmf9atoBERGRamX19n28O2MdA/s0pUFijNdxKlRUhI+0OnGVOjqurJPEAeCcywQyg7+fXAl5JISd3rEBPZrV4Q/vz+Xvny0ic/FWHh/QtVrMyChSGVQzpUFiDKOu7c2rE1bxj88XceZT4/n3gK6c0CbF62giIiKV4ulvlhHpN27KaOV1lErRvF58yB5BlxqoXq1oXry6J49d3IVZa3dx5pPj+XzuRq9jiYiELJ/PuO74Fnx4y3EkxkZy9ctT+PtnCzWnh4iIVDsrtmbxwcx1XN23GfUTqtfR84Na1I1j1bbsSjt1TQ26lJuZMaBXEz69/QSa143jptdncM+7s9l3IN/raCIiIatDo9r899bjuapvU4Z/v4KL/vOjJpATEZFq5ZlvlxEd4eeG/tXz6DkEjqBnHchnW1ZupTy/GnQ5Yi3qxfPuTcdyy0mteGf6Os595gfmrd/tdSwRkZAVG+XnoQs7M/zqnqzdsZ9znx7PR7PWex1LRETkqGUdyOfTuRu5ND2NerWivY5TaX6ayb2ShrmrQZejEun38fsz2vPm9X3Jzs3noucn8OqPKzVbsYjIIZzesQGf33ECxzSszR1vzeKed2eTnatRSCIiEr7GLdpCbn4h53Ru6HWUStWi7s/XQq8MatClQvRtWZfP7ziR49vU46//XcCw16azc1/lDPsQEakOGiXF8tawvtx6Umvemb6O85/VZSxFRCR8fTFvE/VqRZHePNnrKJUqrU4sET6rtGuhq0GXCpMcH8XLg9L587kdyFy8hbOfHs/01Tu8jiUiErIi/D7uPqMdr13Xh13ZeVzw3A+8O32d17FERETKJSevgHGLt3B6xwb4feZ1nEoV4ffRJDlOQ9wlPJgZQ45vwXs3HUuk38dlL07ipe9XaMi7iMghHN+mHp/dcTzdmiRx9zuzuffdOeTkFXgdS0REpEy+W7KV7NwCzurUwOsoVaJ53ThWbsuulOdWgy6VoktaEv+97XhOOaY+D3+2kGGvTWd3dp7XsUREQlb9hBjGDOnDrSe15u1pa7nwOc3yLiIi4eGLeZtIjI2kb8u6XkepEs3rxbNq275KOQipBl0qTWJsJC9c1ZM/n9uBcYu2cO6z45m7TrO8i4iU5uCQ91eu7cXmPTmc98wPfD53o9exRERESpWbX8jXCzdzWodUIv01o71sWS+e/XkFbN5zoMKfu2ZsQfHMwSHvY2/sR0GB4+L/TOCNyWs05F1E5BBOalefT28/gdb1a3HT6zP4+2cLyS8o9DqWiIjIr/y4fBt7c/JrzPB2+PlSa5Ux0k0NulSJHk3r8OntJ9C3VV3+8MFcfq/zK0VEDqlRUixv39CXq/s2Y/j3K7jq5cls3Vvxe+pFRESOxhdzN1ErOoLj29TzOkqVaV638q6FrgZdqkyd+CheGdyL209pw7vT13HR8xNYs71yJlcQEakOoiP8/N+FnXjisq7MWruLc54ez7RVujqGiIiEhvyCQv63YBMnt69PdITf6zhVplFSLFF+X6Vcak0NulQpv8+467S2vDK4F+t37efcZ8bz7aLNXscSEQlpv+mexgc3H0dclJ/Lh0/itYmrdKqQiIh4bsrKHezMzqtRw9sh0NM0rRunIe5SfZzUvj6f3HY8TZLjuO7VaTz59RIKC/VlU0SkNMc0rM1Htx7PiW1T+PNH87lHpwqJiIjHPp+3iZhIH/3bpXgdpco1rxuvIe5SvTRJjuO9m47lou6NefLrpVw/ehq79+tSbCIipUmMjWTENencfnJr3pm+jstenMiGXfu9jiUiIjVQYaHjy/mbyGhbn7ioCK/jVLkW9eJYvT2bwgoe0aYGXTwVE+nn8QFdefCCjny3ZCsXPvcjizft9TqWiEjI8vmMu05vx4tX92T51n2c98wPTF6x3etYIiJSw8xYs5Mtew9wVueaNbz9oOb14jmQX8jOHDXoUs2YGdf0a86bw/qSdSCf3zz/I5/pur8iIod0RscGfHjLcSTGRTJwxGRem7Ta60giIlKDjFu8Bb/POKl9fa+jeKJFcCb3zdlq0KWa6tU8mU9uO552DRK4+fUZ/PPLRRTovHQRkVK1rl+LD285jhPa1OPPH87jDx/MJTdf10sXEZHKN3XlTjo1TqR2TKTXUTxx8From/ZV7OeuGnQJKam1Y3hrWF8u79WE58YtZ+ioqTovXUTkEGrHRDJiUC9uymjFG5PXMHDEJLZl6XrpIiJSeXLyCpi1dhd9WiR7HcUzDWrHEB3hY3O2GnSp5qIj/DxyUWceurAT45du48LnfmTZFp2XLiJSGr/PuPfM9jx1eTfmrt/N+c/8wPwNu72OJSIi1dTstbvILSikd/Oa26D7fEbzuvFs3qch7lIDmBlX9W3GG9f3ZW9OHhc+N4FvFup66SIih3JBt8a8e+OxOOCS/0zki3maz0NERCrelJU7MAucolqTXd2vGekN/BX6nGrQJaT1bpHMx7ceT4t68QwdPY3nM5fhKvhSBiIi1Umnxol8dMtxtGuQwI1jZvDMN0tVN0VEpEJNWbWDdqkJJMbVzPPPD7qqbzOOb1yx20ANuoS8RkmxjL2hH+d2acRjXyzmjrdmsT+3wOtYIiIhq35wPo8LuzXi8a+WcPtbs8jJU90UEZGjl19QyPTVO+ldg88/r0w174ryEpZio/w8fXk3jmmYwD+/XMyKbVm8dE06DRNjvY4mIhKSYiL9PHFZN9o2CNTNNdv38dKgdK9jiYhImJu/YQ/ZuQVq0CuJjqBL2DAzbs5ozYhr0lm1LZvzn/2RmWt2eh1LRCRkHaybL17VkyWbs7jw2R9Zs0dH0kVE5MhNWbkDoEZPEFeZ1KBL2DnlmFTev/lYYiJ9XDZ8EhM35HsdSUQkpJ3esQHv3NiPQgd/n5yjSTdFROSITV65g+Z146hfO8brKNVSmRt0M/Ob2Uwz+yR4u4WZTTazZWb2tplFVV5MkV9qm5rAR7ccT7cmSbw45wD//HIRhYWaBElCh2qmhJpOjRP56NbjaBDvY+joaYwYv0KTx4mISLkUFjqmrtqh4e2VqDxH0O8AFha5/SjwhHOuNbATGFKRwUQOJzk+ijFD+nBiWgTPjVvOjWOmk52ro+kSMlQzJeSk1o7h/j4xnNGhAQ99upA/fTiP/IJCr2OJiEiYWLoli9378+jdoq7XUaqtMjXoZpYGnAOMCN424GTg3eAio4ALKyGfyCFFRfi4tmMUD5zbga8XbubSFyayaXeO17GkhlPNlFAW7TeeH9iDG/u34vXJaxgyahp7c/K8jiUiImFgysrtAPTREfRKU9ZZ3J8E7gESgrfrAruccwcPV64DGpe0opkNA4YBpKamkpmZWe6QWVlZR7Sel5S56uzbt4+WtVZze/doXpi9hzP//S139oimeaLf62ilCtdtHY65Pcr8JKqZ5RKOmSE8c2dlZfH999/RNxYOdIxi1IKtnPWvr/htzxjqxobu1DThuq3DLTNUXW4zOxN4CvADI5xz/yj2+I3ALUABkAUMc84tqPRgIlKqySt30DAxhrQ6upJSZTlsg25m5wJbnHPTzSyjvC/gnBsODAdIT093GRnlfgoyMzM5kvW8pMxV52DuDOCME/Yw5NWpPDotjycv78gZHRt4Ha9E4b6tw0lVZ1bNPDLhmBnCM3fRzBnAyUu3cvOYGTw6o5CXB/Wkc1qil/FKFe7bOpxURW4z8wPPAacR2Gk51cw+LtaAv+GceyG4/PnAv4EzKzWYiJTKOceUlTvo27IugcGBUhnKsqv8OOB8M1sFvEVgmOZTQJKZHWzw04D1lZJQpByOaVibD289jrYNErhxzHSGf79ckyBJVVPNlLByQpsU3r3pWCL9Pga8OFEzvEtV6Q0sc86tcM7lEqiXFxRdwDm3p8jNeEAf6CIeWr09my17D2iCuEp22CPozrn7gfsBgkeD7nbODTSzd4BLCBTUQcBHlRdTpOzqJ8Tw9rC+/G7sbP7+2SJWbc/mwfM7EuEP3aGbUn2oZko4atcggQ9uOZYhr07j+tHT+NsFnbi6bzOvY0n11hhYW+T2OqBP8YXM7BbgLiCKwA7PXznaU4N0KkLVCcfMEJ65KyPz+HWB+Ups23IyM1dW6HMfpG1d9nPQS3Iv8JaZPQTMBF6umEgiRy8m0s8zV3SnSXIcL3y3nPU79/Psld1JiIn0OprUXKqZEtLqJ8Tw1rC+3P7mTP784TzW7czm3jPa4/NpGKN4xzn3HPCcmV0J/InADs7iyxzVqUE6FaHqhGNmCM/clZH5k3dmkxy/hSvPOanShrhrW5fvMms45zKdc+cGf1/hnOvtnGvtnLvUOXegwlKJVACfz7jvrPY8clFnfli2jUtfmMiGXfu9jiU1iGqmhJv46AhevLonV/VtyovfreD2t2aSk1fgdSypntYDTYrcPtypP2+hq1+IeGrKyh30al5H559XMo35lWrvit5NefXaXqzfuZ/fPP8j8zfs9jqSiEjIivD7+L8LOnH/We35ZM5Grhk5hd3ZugybVLipQBsza2FmUcDlwMdFFzCzNkVungMsrcJ8IlLElj05rNmRTa/mOv+8sqlBlxrh4CRIfjMGvDCRzMVbvI4kIhKyzIwb+rfi6Su6M2vNLi5+YQLrNQJJKlDwspO3Al8CC4Gxzrn5ZvZgcMZ2gFvNbL6ZzSJwHvqvhreLSNWYvS5wgKtbkyRvg9QAatClxghMgnQczerGM2TUNN6assbrSCIiIe38ro0YdV1vNu/J4TfP/ciCDXsOv5JIGTnnPnPOtXXOtXLOPRy87wHn3MfB3+9wznV0znVzzp3knJvvbWKRmmvOul34fUbHRqF5Kc7qRA261CiptWMYe2M/jmtdj/ven8u/vlysy7CJiBxCv1Z1effGY/GZMeDFify4bJvXkUREpIrNXrebNvVrERvl9zpKtacGXWqcWtERvDwonct7NeHZccu4a+xscvMLvY4lIhKyDl6GrXFSLINfmcKHMw81l5eIiFQnzjnmrNtF17Qkr6PUCGrQpUaK9Pt45KLO/O60tnwwcz3XvjqFPTmaBElEpDQNE2MZe2M/ejStw51vz2LE+BVeRxIRkSqwdsd+dmXn0aWJhrdXBTXoUmOZGbed0oZ/XdqVySt2MOCFiWzcrUmQRERKkxgbyajrenN25wY89OlCHv50AYWFOk1IRKQ6m71uF4COoFcRNehS413SM41Xru3Fup37+c1zE1i0SZMgiYiUJibSzzNX9GBQv2a8NH4lvx07S6cJiYhUY3PW7SIqwke7BgleR6kR1KCLELgM29s39KXQOS79z0QmLNckSCIipfH7jL+e35F7zmzHR7M2MGTUVLIO5HsdS0REKsHsdbvp0LA2kX61jlVBW1kkqGOjRD645TgaJMYwaOQUPp69wetIIiIhy8y4OaM1/7ykCxOWb+fKlyaxPeuA17FERKQCFRQ65q3fTdc0nX9eVdSgixTROCmWd288lu5N6nD7mzN56fsVugybiMghXJrehOFX92TJ5r1c+sJE1u7I9jqSiIhUkOVbs8jOLaCLzj+vMmrQRYpJjItk9JDenNO5IQ9/tpAHP9EkSCIih3LKMam8PrQP27IOcMkLmstDRKS6mL12FwBdNYN7lVGDLlKCwCRI3bnuuBa88uMqbn1zBjl5BV7HEhEJWT2bJfPOjccCMOCFiUxdtcPjRCIicrTmrNtNregIWtar5XWUGkMNukgpfD7jgfM68KdzjuGzuZu4ZuQUdmfrWukiIqVp1yCB9246lnoJ0Vw1YjLfLtrsdSQRETkKs9ftolPj2vh85nWUGkMNushhDD2hJU9f0Z2Za3Zy6YsT2LBL10oXESlNWp043rmhH21TE7h+9HTen7HO60giInIEDuQXsHDjHl3/vIqpQRcpg/O7NmLUtb3ZuCuHi56fwOJNe72OJCISsurWiubNYX3p0yKZu8bOZuQPK72OJCIi5bRo417yChxdmyR5HaVGUYMuUkbHtq7H2zf0o9A5LnlhApNWbPc6kohIyKoVHcHIwb04s2MDHvxkAf/6crGuiiEiEkbmrNsFQBddYq1KqUEXKYcOjWrz/s3Hklo7hmtGTuHzuRu9jiQiErJiIv08N7AHl/dqwrPjlvHnj+bpqhgiImFi9rrd1I2PonFSrNdRahQ16CLllFYnjndv7EenRrW5+Y0ZvDZxldeRRERClt9nPHJRZ27o35Ixk9Zw59uzyCso9DqWiIgcxpx1u+iSloiZJoirSmrQRY5AUlwUrw/tyyntU/nzR/M1dFNE5BDMjPvPOoZ7zmzHx7M3cMNr09mfq0tXioiEqn0H8lm2JYsumiCuyqlBFzlCsVF+Xrjq56Gb9703l3wdFRIRKdXNGa15+DedGLd4C4NGTmFPji5dKSISiuat302hg65NdP55VVODLnIUIvw+HrmoM7ef3Jq3p63lxjEzyMnTUSERkdIM7NOMpy7vzow1O7li+CS2Zx3wOpKIiBQzZ91uAB1B94AadJGjZGbcdXo7HrygI98s2sw1L09h934dFRIRKc35XRvx0jXpLNuSxYAXJ7Jpd47XkUREpIjZ63bROCmWerWivY5S46hBF6kg1/RrzlOXd2fm2p1c9uJEtuzRF04RkdKc1L4+o67rzeY9B7jkhQms3r7P60giIhI0d/1uXV7NI2rQRSrQ+V0b8fKgXqzZkc0lL0zUF04RkUPo27Iub1zfh6wD+Vz6wkQWb9rrdSQRkRpvV3Yuq7dn01kNuicO26CbWYyZTTGz2WY238z+Frz/VTNbaWazgj/dKj2tSBg4sW0Krw/tw56cPC7+z0QWbdrjdSQRkZDVJS2JsTf0A+Cy4ROZvXaXt4FERGq4uesD55931fnnnijLEfQDwMnOua5AN+BMM+sbfOz3zrluwZ9ZlZRRJOx0b1qHd27oh98Hl704iZlrdnodSaqQdmyKlE/b1ATevfFYakVHMHDEZKas3OF1JBGRGuvgBHGdGusIuhcO26C7gKzgzcjgjy74LHIYbYJfOBNjIxk4YjITlm/zOpJUHe3YFCmnpnXjePfGY0mtHc01Iyfz3ZKtXkcSEamR5qzbRYt68STGRnodpUaKKMtCZuYHpgOtgeecc5PN7CbgYTN7APgGuM8596trpZjZMGAYQGpqKpmZmeUOmZWVdUTreUmZq06o5/5tF8e/phVyzcuTuaVbNN3rR4R85tKEY24vMjvnHKAdmyLl1CAxhrdv6Mc1L09h6KipPHNFD87s1MDrWCIiNcrcdbtJb57sdYwaq0wNunOuAOhmZknAB2bWCbgf2AREAcOBe4EHS1h3ePBx0tPTXUZGRrlDZmZmciTreUmZq0445M44IZdBr0zh2Vl7eOKyDtRmSchnLkk4bOvivMp8NDs2RWqyerWieXNYXwa/MoVb3pjBvy7twm+6p3kdS0SkRti69wAbdudoBncPlalBP8g5t8vMxgFnOuf+Fbz7gJm9Atxd4elEqok68VG8PrQPQ0ZN4863ZnJdpygyvA4llepId2xq1FF4Ccfc4ZL5hraOp7KMu96ezex5C0mvcyAschcVLtu6uHDNLSJHb+76XUBgAk/xxmEbdDNLAfKCzXkscBrwqJk1dM5tNDMDLgTmVW5UkfCWEBPJqGt7c/3oabw8dxstJ6/hyj5NvY4llay8OzY16ii8hGPucMqc0b+Am8ZM59X5WznQPppHzs3wOlK5hNO2Lipcc4vI0Zu9djc+g46NansdpcYqyyzuDYFxZjYHmAp85Zz7BHjdzOYCc4F6wEOVF1OkeoiN8jNiUDqdU/z84YO5vPrjSq8jSSUws5TgkXOK7NhcZGYNg/dpx6ZIGcRE+nnx6nTO6tSANxfl8uy3S72OJCJSrc1dv5vW9WsRH12ugdZSgQ675Z1zc4DuJdx/cqUkEqnmYiL93NY9mnfWJfDX/y7gQH4hN/Rv5XUsqVgNgVHB89B9wFjn3Cdm9m1wVJIBs4AbPcwoEhaiInw8c0V3rn7uf/zrf0vYn1fA3ae3I7CfS0REKopzjjnrdtG/bX2vo9Ro2jUi4oFIn/HcwB7c+fYsHvl8EYUObspQk15daMemSMWK8Pu4vnM0zdPq8ty45ezPLeTP5x6jJl1EpAJt3J3DtqxcujbRBHFeUoMu4pFIv4+nLuuGz4xHv1iEGdyoI+kiIiXymfH333QmJtLPyB9XciC/gP+7oBM+n5p0EZGKMGfdLgA6N1aD7iU16CIeivD7eGJAVwD+8fkiDDTcXUSkFGbGA+d2ICbSz38yl3Mgv5BHL+6CX026iMhRm7NuNxE+45iGmiDOS2rQRTxWtEl/5PNFgJp0EZHSmBn3nNGO6AgfT369lNz8Qv49oCsR/rLMeysiIqWZs2437RokEBPp9zpKjaYGXSQEFG/SzWDYiWrSRURKYmbceWpboiP8PPrFInLzC3n6iu5ERahJDydmdibwFOAHRjjn/lHs8buAoUA+sBW4zjm3usqDitQAByeIO6dLI6+j1Hj6JBMJEQeb9HO7NOTvny3iFV2CTUTkkG7KaMUD53bgi/mbuPn16RzIL/A6kpRR8CoXzwFnAR2AK8ysQ7HFZgLpzrkuwLvAY1WbUqTmWLMjmz05+XRJ0/nnXlODLhJCIvw+nrisG2d0TOVv/13A65N1oEBE5FCuO74FD/+mE18v3ML1o6eTk6cmPUz0BpY551Y453KBt4ALii7gnBvnnMsO3pwEpFVxRpEaY/a63QBq0EOAhriLhJhIv49nrujBTWOm88cP5hHp9zEgvYnXsUREQtbAPs2I9Pu49705XPfqVEYMSicuSl9xQlxjYG2R2+uAPodYfgjweUkPmNkwYBhAamoqmZmZ5QqSlZVV7nVCQTjmDsfMEJ65y5v5s0UHiPDBxkUz2LrEu4k3a8K2Phx9eomEoKgIH88N7MH1o6dx73tziPL7uLB7Y69jiYiErAHpTYj0G78bO5vBI6cy8tpe1IrW15zqwMyuAtKB/iU97pwbDgwHSE9PdxkZGeV6/szMTMq7TigIx9zhmBnCM3d5Mz+/eCKdGhdy6snHVV6oMqgJ2/pwNMRdJETFRPoZfnU6fVvU5a6xs/h87kavI4mIhLTfdE/j6Su6M33NTq5+eTJ7cvK8jiSlWw8UHR6WFrzvF8zsVOCPwPnOuQNVlE2kRikodMxfv5uuGt4eEtSgi4Sw2Cg/Iwal071pHW5/aybjFm3xOpKISEg7t0sjnh/Yg3nrd3P1iMnszlaTHqKmAm3MrIWZRQGXAx8XXcDMugMvEmjO9QEoUklWbM1iX24BndOSvI4iqEEXCXnx0RG8cm0v2jVI4IYx05mwbJvXkUREQtoZHRvwn4E9WbhxLwNfnsTOfbleR5JinHP5wK3Al8BCYKxzbr6ZPWhm5wcX+ydQC3jHzGaZ2celPJ2IHIWZa3YB0K2JjqCHAjXoImGgdkwko6/rQ/O6cQwdPY3pq3d4HUlEJKSd2iGVF6/pyZLNWVw5YjLbszQ6OtQ45z5zzrV1zrVyzj0cvO8B59zHwd9Pdc6lOue6BX/OP/QzisiRmLpqB3XiImmVUsvrKIIadJGwkRwfxZihfUitHcPgkVOZt36315FERELaSe3qM+KadFZszeLKlyazTU26iMivTF21g/TmyZh5N3u7/EwNukgYqZ8Qw+tD+1A7NpKrX57Mks17vY4kIhLSTmybwiuDe7F6xz6uGD6JLXtzvI4kIhIytuzNYdX2bHo1r+N1FAlSgy4SZholxfLG9X2I9PsYOGIyq7bt8zqSiEhIO7Z1PV69tjfrdu4PNOl71KSLiABMW7UTgF7Nkz1OIgepQRcJQ83qxvP60D7kFxQycMRkNuza73UkEZGQ1rdlXUZd15uNu3O4fPgkNu1Wky4iMnXVDmIifXRspAniQoUadJEw1SY1gdeG9GHP/jwGjpisYZsiIofRu0Uyo6/rzZa9B7h8+EQ27tbOTRGp2aau2kH3JnWIilBbGCr0LyESxjo1TuTV63qxaXcOV4+YoksJiYgcRnrzZEZd15ttWblc9uIk1msEkojUUHtz8liwYQ+9Wmh4eyhRgy4S5no2S2bEoHRWbt/H4FemsDcnz+tIIiIhrWezOrw2pDc7s3O5fPhENekiUiPNXLOLQocmiAsxatBFqoHjWtfj+St7MH/DHq57dSrZufleRxIRCWndm9ZhzJA+7MrO4/LhE1m3M9vrSCIiVWrqqh34fUb3pmrQQ4kadJFq4tQOqTx5eTemr97JDa9NJyevwOtIIiIhrWuTJF4f2ofd2XlcPnwSa3eoSReRmmPqqh10aFibWtERXkeRItSgi1Qj53ZpxKMXd2H80m3c+sZM8goKvY4kIhLSuqQl8frQvuzNyVeTLiI1Rm5+ITPX7NLl1UKQGnSRaubS9CY8eEFHvl64mbvGzqag0HkdSUQkpHVOS+T1oX3IOqAmXURqhnkbdnMgv5DeLTS8PdSoQRephq7p15z7zmrPf2dv4N735lCoJl1E5JA6NVaTLiI1x9SVO4DAZMMSWtSgi1RTN/ZvxR2ntOHd6et44ON5OKcmXUTkUNSki0hNMXXVDlrWiyclIdrrKFLMYRt0M4sxsylmNtvM5pvZ34L3tzCzyWa2zMzeNrOoyo8rIuVx56ltuLF/K8ZMWsNDny5Uky4ichhq0kWkuissdExbvZN0XV4tJJXlCPoB4GTnXFegG3CmmfUFHgWecM61BnYCQyotpYgcETPj3jPbMfjY5rz8w0r+9b/FXkeqEbRjUyS8qUkXkeps2dYsdmXnaYK4EHXYBt0FZAVvRgZ/HHAy8G7w/lHAhZURUESOjpnxl/M6cEXvpjw3bjnPfLPU60g1gXZsioQ5NekiUl1NXRU4/7x3CzXooahMF70zMz8wHWgNPAcsB3Y55/KDi6wDGpey7jBgGEBqaiqZmZnlDpmVlXVE63lJmatOOOb2IvNpdRxrGkXw+FdLWLt6JWe3LP/BW23rsnGBcwlK27F5ZfD+UcBfgf9UaTgRKbODTfrAEZO5fPgk3hrWlybJcV7HEhE5KlNX7iAlIZqmqmchqUwNunOuAOhmZknAB0D7sr6Ac244MBwgPT3dZWRklDtkZmYmR7Kel5S56oRjbq8y9+/v+O3bsxg7ewNt27Rm6Akty7W+tnXZHc2OTREJHQeb9CtfmsQVLwWa9LQ6+lIrEo6ccyzdksWCDXvYeyCfrJx89h3IZ19uPslxUbRIiad53Xha1IsnPrpMbVLYcc4xeeUOejdPxsy8jiMlKNf/ec65XWY2DugHJJlZRPDLZhqwvjICikjF8fuMfw/oSn5hIQ99upCoCB/X9Gvudaxq6Uh3bGrUUXgJx9zhmBm8z31X9wgem7qf3zydyX29Y6gbe/hpfLzOfKTCNbdISfILCpm6aidfL9zMVws2s6bY6So+g/ioCPYeyP/F/Q1qx9CpcSJd0hJhRz5d9uWSHB/+U8fMWbebjbtz6N8uxesoUorDNuhmlgLkBZvzWOA0AudRjgMuAd4CBgEfVWZQEakYEX4fT13enbyCGTzw0XwifD6u7NPU61jVVnl3bGrUUXgJx9zhmBlCI3ePnru4asRknpwLbw3rQ+Ok2EMuHwqZj0S45g5HK7Zm8f6M9ezIziXSZ/h9PiL8RnxUBMe2rkv3JklE+HVV5COxOzuPVyasZNSEVezMziMqwsdxrepyQ/+W9GlRl9qxESRERxIT6cPM2J9bwKrt+1i1bR8rtu1j6ea9zF2/m28WbcY5+Pf0r6ifEE2T5DjS6sTSpE7gv7ViIojy+4iKCPzERPqJj4ogPjrw37hoP9ERfq83x08+m7uRSL9xRocGXkeRUpTlCHpDYFRwuKYPGOuc+8TMFgBvmdlDwEzg5UrMKSIVKNLv49kru3PTmBn84YO5RPiMAb2aeB2r2tCOTZHqqUtaEq8N6cNVL0/miuGTePuGvjRMPHSTLlJcbn4hX87fxBuT1zBxxXb8PqNOXCT5hY6CAkd+oSMnv4AnvoakuEj6t03h5Pb1Oal9fWrHRHodP+Tt3JfLyB9X8uqPq9h7IJ9Tj0nlkp6NOaFNyiGHrcdG+TmmYW2OaVj7F/fvzcljzKff46vXnGVbsli7M5tpq3by39kbKCzj1WubJseR0S6FjHYp9G1Zl7gob4bPO+f4ZM5Gjmtdj8Q4/b8Uqg77f4dzbg7QvYT7VwC9KyOUiFS+6Ag/zw/swfWjp3Hv+3Pw+4yLe6Z5Hau60I5NkWqqa5MkRl/Xm2tensIVwyfx1rB+NEiM8TqWhImx09by6OeL2L4vl7Q6sfz+jHZcmp5G/YRf/j+0JyePH5Zu45uFWxi3eAsfzdpAXJSfS3qmMfjY5rRMqeXROwhdO/flMnz8CkZPWMW+3ALO7tyAW09qQ4dGtQ+/8iEkxERyTF0/Gf1b/eL+vIJCNu/JITu3gNz8Qg7kF5KbX0hOfgHZBwrYlxs4v31vTj6z1+7inWnrGD1xNVERPvq2rMs9Z7SjU+PEo8pWXnPW7Wb9rv3ceWqbKn1dKZ/qOfuBiJRJTKSfl65JZ+ioadz97mz8PuPC7pq37Ghpx6ZI9da9aR1GDQk26cGJ41Jrq0mXQ3vp+xU8/NlCerdI5vGMVpzYJgWfr+RJumrHRHJ254ac3bkhBYWOWWt38uaUtbw1ZS2jJ67mlPb16ZlQQH/navxEX7v35/HyDysZ+cNK9uXmc07nhtx2chvaNUio1NeN9PvKNWFkTl4BU1ft4LvFW/lw1gYufO5H7jilDTdltKqy0xgODm8/XcPbQ5oadJEa7mCTPmTUVO4aOwufzzi/ayOvY4mIhLQeTesw6rpeRY6k96W+mnQpgXOOJ79eylPfLOWczg154rJuREWUvSHz+4yezZLp2SyZe89sz5hJq3l98mq+ycrl47XjGXpCS87v2qhcz1kd7MrOZcyk1Qz/fgV7cvI5q1MDfntaW9qmVm5jfqRiIv2c0CaFE9qkcOvJrfnTh/N4/KslfLNoC/8e0LXSR0UcHN5+vIa3hzw16CJCbJSfEYPSufaVqfz27Vn4zTinS0OvY4mIhLSezZIZdV1vrhl58Eh6P1ISor2OJSHEOcfDny5kxA8rubRnGv+4uAv+Uo6al0VKQjS/Pa0tN2W04p9vf8sPW+Hud2bz2BeLGHRscwb2aUpSXOXONO6cY8PuHGas3snSLVms37mf9buyWb9rP5t3HwCD6CKTptWOiaR5vThaptQid1seCat30Lp+Aomx5W8Sc/MLyVy8hfdnrOfbRVvILSjk1GPqc+epbat8uPjRSIqL4tkre3B6xw38+cN5nP30eP5yXkeu6F15k/ZqeHv4UIMuIgDERUUwcnAvrn1lKre/NROfwVmd1aSLiBxKevNkXhnci8GvTOXKlybx5rC+1KulJl2gsNDxxw/n8uaUtQw+tjkPnNuh1CHt5RUT6eeEtEj+NPAEvl+6jRHjV/DPLxfz9DdLOfWYVM7v1oiMdikVMnt4fkEhCzbuYeqqncxYvZPpq3eyaU8OAGaQmhBD4zqxdG9Sh4adYsACjfTBn53ZeSzbksW3i7aQV+B4ed5EABonxXJMwwTaN6hNm9RapCREkxwfRXJcFElxUeQXFrJ2x35Wb9/Hmh3ZLNuSxZfzN7EzO496taK4qm8zLu7ZmI6NwqcxL+78ro3o0yKZu9+Zzf3vz6XQOQb2aVYpr/WphreHDTXoIvKT+OgIRl7bi8Ejp3DbmzN51owzO6mQi4gcSp+WdQM7OF+dwsCXJvPmsL7V4nrJcnRen7KGN6es5ZaTWnH36e0q5VxxM6N/2xT6t01h4cY9vDVlDZ/M2cinczdSOyaCszs3JKNdCh0bJZJWJ/awGZxzbMvKZemWvcxYvZPJK3cwY/VO9uUWAJBWJ5beLZLp2awOPZvVoW1qQpmH1ucXFPLuF5mktOzI4s17WbRxL4s27WHc4q0UlGE69IToCE5sl8LFPQIzskdWk8vPpdaOYeTgXgwbPY0/fTiPhJjICj/V0DnHpxreHjbUoIvIL9SKjuCVa3sxaOQUbn1jBs8P7MHpHdWki4gcSr9WdXl5UC+ue3UqA0dM5o2hfbyOJB7asieHxz5fxHGt61Zac17cMQ1r87cLOvGnczvw47JtfDRrAx/P3sBbU9cCgQb3mEa1aZtai5jgkfWDsXbvDxzlXrYliz05+T89Z/sGCVzUI43eLZLp1Tz5qK5YEOH30SDeR8YxqZxyTOpP9+fkFbB6ezY79uWyMzuXHfty2ZWdi5nRNDnup5+kuMhqOyFepN/H8wN7MuiVKdz19iwSoiM4qX39Cnv+2cHh7b89rW2FPadUHjXoIvIrCTGRvHpdb65+eQq3vDGD/wzsyakdUg+/oohIDXZc63qBK2OMnsZVL0/mpvZlvEiyVDt/+2QBBwoKeejCzlXeVEb6fWS0q09Gu/rk5BWweNNeFmzcw/wNu1mwYQ8fz9pAQaGj6P+d8dERtEqJ5/xujWiVUotWKbXokpZY6eezQ2C4fmXPuB4OYqP8vDwonStemsSNY6Yz+rre9GlZt0Ke++Ds7afpu1xYUIMuIiWqHRMZvNbvZG5+fQYvXN2D6jGYTESk8pzYNoUXr+7JDaOn83gWnHBC3hFNhiXha9yiLXw6ZyN3n96WFvXiPc0SE+mna5MkujZJ8jSHlE1CTCSjru3NgBcnMmTUNN4a1veoJ787OLz9hDYpqkVhQt+3RaRUibGRjB7Sh3YNErjxtRnM2Zp/+JVERGq4k9rV5/mBPVizt5BBI6ewNyfP60hSRbJz8/nTh/NoXb8Ww05s5XUcCUN1a0UzZmgfasdEMGTUVDbu3n9Uz3dwePvZmvg3bKhBF5FDSoyN5LUhvWmTWounZx7g+yVbvY4kIhLyTu2Qys3dopm3fjfXvjKVfQe0g7MmeOrrpazftZ9HLupc465LLhWnYWIsI6/txb4DBQx5ddpR1Y/RE1ZpeHuYUeUQkcNKiotizJA+NIz3cf3oafywdJvXkUREQl7P1AievqI7M9fu4tpXp5Kdqya9Opu/YTcjfljJFb2b0Kt5stdxJMy1b1CbZ67szqJNe7jjrVllmum+uHGLt/D+zPXccGIrDW8PI2rQRaRM6sRHcU+vGFrUi2fo6KlMWKYmXUTkcM7u3JAnLuvGtFU7GPLqNPYHL1cl1c/fPl5AnbhI7j2zvddRpJo4qV19/nJeR75euJlHPltYrnWz8xz3vzeXtqm1uO2U1pWUUCqDGnQRKbOEKGPM0D40qRPHdaOmMmnFdq8jiYiEvPO7NuLxAV2ZtHI7w16bRk6emnQAMzvTzBab2TIzu6+Ex080sxlmlm9ml3iRsaxmr93FlFU7uDmjdZXMfC41x6BjmzOoXzNG/LCS1yevLvN6by3OZcveHP55SVeig5fVk/CgBl1EyqVerWjeuL4vjZNiue7VqUxbtcPrSCIiIe833dN49OIujF+6jZvGTOdAfs1u0s3MDzwHnAV0AK4wsw7FFlsDDAbeqNp05ffqhFXUio7g0vQ0r6NINfTnczuQ0S6FP384jxHjV+DcoYe7f79kK9+vy2fYia00g38YUoMuIuWWkhDNm9f3JbV2DINfmcrMNTu9jiQiEvIGpDfh77/pzLjFW7n1jZnkFRR6HclLvYFlzrkVzrlc4C3ggqILOOdWOefmACG9obbszeGTORu4pGcaCTE6z1cqXoTfx3NX9uD0Dg146NOF3P7WrFLntNibk8d9782hYbxx56ltqjipVARdB11Ejkj92jG8cX0fLntxEteMnMLrQ/vQJS3J61giIiHtyj5NySso5C8fz+eOt2by9OXdifDXyOMljYG1RW6vA/ocyROZ2TBgGEBqaiqZmZnlWj8rK6vc6xT14bJc8goc7f2bycysuiudHG1uL4RjZgid3JelOWrlRfLe7A3MXL6R23vEUD/u5/qRW+AYszCXjbvz+W0Xx6Qfx3uY9siEyrYuj4rOrAZdRI5Yw8RY3hzWl8tenMjVLwea9E6NE72OJSIS0gYd25y8gkIe+nQhEb7ZPHFZN/w+8zpW2HLODQeGA6Snp7uMjIxyrZ+ZmUl51zkoN7+Qu3/4lpPapXD5Ob2P6DmO1NHk9ko4ZobQyn3SSXD+kq3c/tZMHpqSx3ldG7FmRzYrt+1j/a79OAdDj29Bl1pbQiZzeYTSti6ris5cI3fZikjFaZwUy5vX9yU+ys/VL09m0aY9XkcSEQl5Q09oyb1ntufj2Ru45905FB7BJZTC3HqgSZHbacH7wspnczeyLesAg49r4XUUqUFObJvCf289npYptfho1gZ2ZefRo2kd7jilDc9d2YP7ztKVBMKZjqCLyFFrkhzHm8P6MuDFiVw1YjJvDetH6/q1vI4lIhLSbspoRW5+IU98vYRIv/H333TGV3OOpE8F2phZCwKN+eXAld5GKr9XJqyiZUo8J7Su53UUqWGaJMfx4S3H4ZzDrMbUjRpBR9BFpEI0qxvPG9f3BYwrX5rEqm37vI4kIhLybj+lNbee1Jq3pq7lLx/PP+zszNWFcy4fuBX4ElgIjHXOzTezB83sfAAz62Vm64BLgRfNbL53iX9txpqdzF67i8HHNq9JO1YkxKg5r37UoItIhWmVUos3ru9DfqHjypcmsXZHtteRRERCmpnxu9PbMuzElrw2aTUPfbqwJjXpnznn2jrnWjnnHg7e94Bz7uPg71Odc2nOuXjnXF3nXEdvE//Sqz+uIiE6got66NJqIlJx1KCLSIVqm5rAa0N6sy+3gCtemsSGXfu9jiQiEtLMjPvPas/gY5vz8g8reezLxTWmSQ9Xm/fk8NncjVya3oRa0TpjVEQqjhp0EalwHRsl8tqQ3uzOzmPgiMls2ZPjdSQRkZBmZvzlvA5c2acp/8lczlPfLPU6khzCu9PXkV/ouKZfM6+jiEg1owZdRCpFl7QkXr2uF5v35DBwxGS2Zx3wOpKISEgzMx66oBOX9Ezjya+X8nzmMq8jSSk+n7eR7k2TaF4v3usoIlLNqEEXkUrTs1kyIwals2ZHNle/PIXd2XleRxIRCWk+n/HoxV24oFsjHvtiMSPGr/A6khSzdkc289bv4cyODbyOIiLV0GEbdDNrYmbjzGyBmc03szuC9//VzNab2azgz9mVH1dEws2xrerx4tU9WbplL9e8MoW9OWrSRUQOxe8zHr+0K2d1asBDny7ktYmrvI4kRXw5fxMAZ3ZSgy4iFa8sR9Dzgd855zoAfYFbzKxD8LEnnHPdgj+fVVpKEQlrGe3q8+yVPZi3fjdDXp1Gdm6+15FEREJahN/HU5d359Rj6vPnj+YzduparyNJ0BfzNnFMw9o0q6vh7SJS8Q7boDvnNjrnZgR/30vgWpWNKzuYiFQvZ3RswJOXdWPa6h0MGz2dnLwCryNVCo06EpGKEhXh47mBPTixbQr3vj+Hj2at9zpSjbdlTw7T1+zkLB09F5FKUq5z0M2sOdAdmBy861Yzm2NmI82sTkWHE5Hq5byujXj04i78sGwbt7w+g9z8Qq8jVQaNOhKRChMd4efFq3rSp0Uyd42dzedzN3odqUb7csFmnNPwdhGpPGW+cKOZ1QLeA+50zu0xs/8A/we44H8fB64rYb1hwDCA1NRUMjMzyx0yKyvriNbzkjJXnXDMHY6ZoWJypwDXdIhi9IItDHz2f9zYJRq/zyokX0mqels75zYCG4O/7zUzjToSkaMSG+Xn5UG9uGbkFG57cyYvRvg45ZhUr2PVSF/M20jLlHja1K/ldRQRqabK1KCbWSSB5vx159z7AM65zUUefwn4pKR1nXPDgeEA6enpLiMjo9whMzMzOZL1vKTMVSccc4djZqi43BlA0/EreOjThTRpVId/XdIVXyU16V5u62Kjjo4jMOroGmAagaPsOz0JJiJhJz46gleu7cVVIyZz05gZvDw4nRPapHgdq0bZuS+XSSt2cMOJLTGrvB3LIlKzHbZBt0AFehlY6Jz7d5H7GwaPFAH8BphXORFFpDoaekJLsnML+PdXS4iJ9PPwhZ2q1RcejToqn3DMDOGZOxwzQ3jmrozMw9o6Ht0NQ16Zwl3pMbRP9lfo80N4buuq8PXCzRQUOg1vF5FKVZYj6McBVwNzzWxW8L4/AFeYWTcCXzZXATdUQj4RqcZuO7k1+/MK+E/mcmIi/Pz53GOqRZOuUUflF46ZITxzh2NmCM/clZW537EHuGz4JJ6ZtZ/RQ3rQs1nFTgMUjtu6KnwxbxONk2Lp3DjR6ygiUo0dtkF3zv0AlPSNWRMcichRMTPuOaMdOXkFjPxxJbFRPn5/RnuvYx0VjToSkcpWt1Y0bwztw4AXJzL4lSm8eX1fOqlprFRZB/IZv3QbV/VtVi12JItI6CrXLO4iIhXNzHjg3A5c2acpz41bzjPfLPU60tE6OOro5GKXVHvMzOaa2RzgJOC3nqYUkbBWv3YMr1/fl9oxkVz18mQWbdrjdaRq7dtFW8gtKOSszhreLiKVq8yzuIuIVBYz46ELOpGTV8DjwXPSrz+xpdexjohGHYlIVWmcFMsb1weOpF81YjJv39CPVimaXbwyfDlvE/VqRdOjqa4qLCKVS0fQRSQk+HzGYxd34ZwuDXn4s4WMmrDK60giIiGvWd143ri+LwADX5rMmu3ZHieqfnLyChi3eAtndEyt1MuCioiAGnQRCSERfh9PXtaN0zuk8peP5/PG5DVeRxIRCXmtUmoxZmgfcvILuHLEJDbs2u91pGpl5ppdZOcWcFK7+l5HEZEaQA26iISUSL+PZ67szsnt6/OHD+YydtparyOJiIS89g1q89p1fdidncfAEZPZsifH60jVxsTl2/AZ9G6Z7HUUEakB1KCLSMiJjvDz/MAenNCmHve+N4cPZq7zOpKISMjrnJbIq9f1YvOeHAaOmMz2rANeRwp5s9bu4vFpOezYl1vqMhOWb6dzWhK1YyKrMJmI1FRq0EUkJMVE+nnpmnT6tazL78bO5r+zN3gdSUQk5PVslszLg3qxZkc214ycwu79eV5HCml+M+ZuK+DbRVtKfDw7N59Za3dxbKu6VZxMRGoqNegiErJiIv2MGJROerNk7nx7Fp/O2Xj4lUREarh+rery4tU9WbJ5L4NfmULWgXyvI4WsTo1rkxxjfDl/U4mPT121k/xCR7+WatBFpGqoQReRkBYXFcHIa3vRo2kSt781U026iEgZZLSrz7NX9mDOut0MHTWV/bkFXkcKSWZGj/p+xi/dWuI2mrB8G5F+I725Lq8mIlVDDbqIhLxa0RG8cm1vNekiIuVwRscG/HtAVyav3MENY6ZzIF9Nekl6pEaQk1fI90u3/uqxScu3071JHeKiIjxIJiI1kRp0EQkLatJFRMrvgm6NefSiLny/ZCu3vTGTvIJCryOFnLZ1fCTGRvK/+Zt/cf/u/XnMXb+bfjr/XESqkBp0EQkbxZv0T+Zo4jgRkcMZ0KsJD17Qkf8t2MxdY2dTUOi8jhRSInzGKe3r882izeQX2YExZeUOCh1q0EWkSqlBF5Gw8osm/c2ZugSbiEgZXNOvOfed1Z7/zt7A/e/PoVBN+i+c3rEBu7LzmLJqx0/3TVi+jegIH92bJnkXTERqHDXoIhJ2akVHMOq63vRtWZe7xs7mzSlrvI4kIhLybuzfittPacPYaev423/n45ya9INObFuP6AjfL4a5T1y+nV7Nk4mO8HuYTERqGjXoIhKW4qIiGDm4F/3bpnD/+3MZNWGV15FERELeb09tw/UntGDUxNU8+sViNelBcVERnNAmha8WbMY5x/asAyzatFfD20WkyqlBF5GwFRPp58Wre3Jah1T+8vF8XvxuudeRRERCmpnxh7OPYWCfprzw3XKe+XaZ15FCxukdU1m/az/zN+xh0orAUHc16CJS1XTNCBEJa9ERfp4f2IPfvj2LRz5fxN6cfH53elvMzOtoIiIhycz4vws6sT+vgH9/tYS4KD9DT2jpdSzPndK+Pj6D/83fxI7sXGpFR9ClcaLXsUSkhlGDLiJhL9Lv46nLuxMfFcGz45axMzuXBy/ohN+nJl1EpCQ+n/HYxV3IySvgoU8XEhcVwZV9mnody1N1a0XTq3ky/1uwmdyCQno1r0OEX4NNRaRqqUEXkWrB7zP+cXFn6sRH8cJ3y9m9P49/D+jmdSwRkZAV4ffx5GXd2Z87jT9+OJfYKB+/6Z7mdSxPnd6xAf/3yQIAruhVs3dYiIg3tFtQRKoNM+O+s9pz/1nt+WTORoaMmsqBfE2AJCJSmqgIH/+5qif9Wtbl7nfm8MW8jV5H8tTpHVJ/+l3nn4uIF9Sgi0i1c0P/Vjx2cRd+XLaNx6bmkJtf6HUkEZGQFRPp56Vr0umalshtb85kwfYCryN5pklyHMc0rE1ibCQdGtb2Oo6I1EAa4i4i1dKAXk2oHRvJV5PnEBWhfZEiIocSHx3BK9f25q8fz6dRrR1V8ppmdibwFOAHRjjn/lHs8WhgNNAT2A5c5pxbVdm5HrygIzv35eLTPCYi4gF9axWRauvMTg04r1WU1zFERMJCYmwkT1zWjaToyv96aGZ+4DngLKADcIWZdSi22BBgp3OuNfAE8GilBwN6NU/m9I4NquKlRER+RQ26iIiIiFS13sAy59wK51wu8BZwQbFlLgBGBX9/FzjFdA1NEanmNMRdRERERKpaY2BtkdvrgD6lLeOcyzez3UBdYFvRhcxsGDAMIDU1lczMzHIFycrKKvc6oSAcc4djZgjP3OGYGcIzd0VnVoMuIiIiImHLOTccGA6Qnp7uMjIyyrV+ZmYm5V0nFIRj7nDMDOGZOxwzQ3jmrujMhx3ibmZNzGycmS0ws/lmdkfw/mQz+8rMlgb/W6fCUomIiIhIdbYeaFLkdlrwvhKXMbMIIJHAZHEiItVWWc5Bzwd+55zrAPQFbglO4nEf8I1zrg3wTfC2iIiIiMjhTAXamFkLM4sCLgc+LrbMx8Cg4O+XAN8651wVZhQRqXKHbdCdcxudczOCv+8FFhI4J6joxB2jgAsrKaOIiIiIVCPOuXzgVuBLAt8txzrn5pvZg2Z2fnCxl4G6ZrYMuAsdDBKRGqBc56CbWXOgOzAZSHXObQw+tAlILWWdo5q4AzRZQFUJx8wQnrnDMTOEZ+5wzCwiUhM45z4DPit23wNFfs8BLq3qXCIiXipzg25mtYD3gDudc3uKXuXCOefMrMQhR0c7cQdosoCqEo6ZITxzh2NmCM/c4ZhZRERERGomK8upPGYWCXwCfOmc+3fwvsVAhnNuo5k1BDKdc+0O8zxbgdVHkLMexS6pEQaUueqEY+5wzAzhmftIMzdzzqVUdJjyUM0MC+GYOxwzQ3jmDsfMcGS5Pa+ZcMR1syb9O3ktHDNDeOYOx8wQnrkr9LvmYRt0CxwqHwXscM7dWeT+fwLbnXP/MLP7gGTn3D1HEOywzGyacy69Mp67sihz1QnH3OGYGcIzdzhmPlrh+J7DMTOEZ+5wzAzhmTscM0P45j5S4fp+wzF3OGaG8MwdjpkhPHNXdOayDHE/DrgamGtms4L3/QH4BzDWzIYQ2FM5oKJCiYiIiIiIiNQ0h23QnXM/AFbKw6dUbBwRERERERGRmqks10EPBcO9DnAElLnqhGPucMwM4Zk7HDMfrXB8z+GYGcIzdzhmhvDMHY6ZIXxzH6lwfb/hmDscM0N45g7HzBCeuSs0c5kmiRMRERERERGRyhUuR9BFREREREREqjU16CIiIiIiIiIhIGQadDM708wWm9my4GXbij8ebWZvBx+fbGbNPYj5K2XIPdjMtprZrODPUC9yFss00sy2mNm8Uh43M3s6+J7mmFmPqs5YQqbDZc4ws91FtvMDVZ2xhExNzGycmS0ws/lmdkcJy4TUti5j5lDc1jFmNsXMZgdz/62EZUKyhhyNcKybqplVIxxrJqhuVhXVzPCpmRB+dTMcayaEZ91Uzaw6VVo3nXOe/wB+YDnQEogCZgMdii1zM/BC8PfLgbfDJPdg4FmvsxbLdCLQA5hXyuNnA58TmL2/LzA5DDJnAJ94nbNYpoZAj+DvCcCSEv7/CKltXcbMobitDagV/D0SmAz0LbZMyNWQo3zPYVc3VTNDKnPI/R0Hc6luVk1m1cwwqJnlyB1SdTMca2YZc4fU33Ewk2pm1eWusroZKkfQewPLnHMrnHO5wFvABcWWuQAYFfz9XeAUMyvt8m9VpSy5Q45z7ntgxyEWuQAY7QImAUlm1rBq0pWsDJlDjnNuo3NuRvD3vcBCoHGxxUJqW5cxc8gJbr+s4M3I4E/xGTBDsYYcjXCsm6qZVSQcayaoblYV1cywqZkQhnUzHGsmhGfdVM2sOlVZN0OlQW8MrC1yex2//of6aRnnXD6wG6hbJelKV5bcABcHh5S8a2ZNqibaUSnr+wo1/YLDTj43s45ehykqOMSlO4G9bUWF7LY+RGYIwW1tZn4zmwVsAb5yzpW6rUOohhyNcKybqpmhJeT+jotS3axcqplhUTOhetbNkP0bLoOQ+jsuSjWz8lVV3QyVBr06+y/Q3DnXBfiKn/eqSMWaATRzznUFngE+9DbOz8ysFvAecKdzbo/XecriMJlDcls75wqcc92ANKC3mXXyOJIcGdXMqhGSf8cHqW5WPtXMakV1s2qE3N/xQaqZVaOq6maoNOjrgaJ7+9KC95W4jJlFAInA9ipJV7rD5nbObXfOHQjeHAH0rKJsR6Ms/x4hxTm35+CwE+fcZ0CkmdXzOBZmFkmg+LzunHu/hEVCblsfLnOobuuDnHO7gHHAmcUeCsUacjTCsW6qZoaIUP47Vt2sWqqZJS8TQu+5OtbNkPsbLotQ/TtWzax6lV03Q6VBnwq0MbMWZhZF4KT6j4st8zEwKPj7JcC3zrni4/6r2mFzFzvH43wC51mEuo+Ba4KzPvYFdjvnNnod6lDMrMHBczzMrDeB/7c9/VAN5nkZWOic+3cpi4XUti5L5hDd1ilmlhT8PRY4DVhUbLFQrCFHIxzrpmpmiAjFv+NgFtXNKqCaGTY1E6pn3Qypv+GyCrW/42AO1cwqUpV1M+IoclYY51y+md0KfElgtsqRzrn5ZvYgMM059zGBf8jXzGwZgQkcLvcucUAZc99uZucD+QRyD/YscJCZvUlgdsR6ZrYO+AuBiQ5wzr0AfEZgxsdlQDZwrTdJf1aGzJcAN5lZPrAfuDwEPlSPA64G5lrgfBWAPwBNIWS3dVkyh+K2bgiMMjM/gSI+1jn3SajXkKMRjnVTNbPqhGnNBNXNqqKaGQY1E8KzboZjzYSwrZuqmVWnyuqmef9eRURERERERCRUhriLiIiIiIiI1Ghq0EVERERERERCgBp0ERERERERkRCgBl1EREREREQkBKhBFxEREREREQkBatAlbJlZkpnd7HUOEZFwobopIlJ2qpniBTXoEs6SABVNEZGyS0J1U0SkrJJQzZQqpgZdwtk/gFZmNsvM/ul1GBGRMKC6KSJSdqqZUuXMOed1BpEjYmbNgU+cc528ziIiEg5UN0VEyk41U7ygI+giIiIiIiIiIUANuoiIiIiIiEgIUIMu4WwvkOB1CBGRMKK6KSJSdqqZUuXUoEvYcs5tB340s3mauENE5PBUN0VEyk41U7ygSeJEREREREREQoCOoIuIiIiIiIiEADXoIiIiIiIiIiFADbqIiIiIiIhICFCDLiIiIiIiIhIC1KCLiIiIiIiIhAA16CIiIiIiIiIhQA26iIiIiIiISAj4f1gPG6g2/MaLAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Now a test for constant values of D:\n", + "test_D = 0.05\n", + "\n", + "def analytic_solution(t, D):\n", + " return 1/D * (-torch.log((1+torch.exp(-2*torch.sqrt(D*g)*t))/2) - torch.sqrt(D*g)*t) + H\n", + "\n", + "# Evaluate model:\n", + "u_model = deepOnet(tp.spaces.Points(t_tensor, T), lambda t: test_D*torch.ones_like(t)).as_tensor[0]\n", + "ref_solution = analytic_solution(t_tensor, torch.tensor(test_D))\n", + " \n", + "# Plot\n", + "plt.figure(0, figsize=(14, 4))\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(t_tensor, u_model.detach())\n", + "plt.title(\"Neural Network\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(t_tensor, ref_solution)\n", + "plt.title(\"Reference Solution\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(t_tensor, torch.abs(ref_solution - u_model.detach()))\n", + "plt.title(\"Absolute Difference\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/Sol1_2.ipynb b/examples/workshop/Sol1_2.ipynb new file mode 100644 index 00000000..5de0d888 --- /dev/null +++ b/examples/workshop/Sol1_2.ipynb @@ -0,0 +1,289 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 1\n", + "\n", + "#### 1.2 Data driven function approximation \n", + "We want to train a neural network that approximates the function \n", + "\\begin{align}\n", + " u(t; D) &= \\frac{1}{D} \\left(\\ln{\\left( \\frac{1+e^{-2\\sqrt{Dg}t}}{2} \\right)} - \\sqrt{Dg} t \\right) + H\n", + "\\end{align}\n", + "In this example we consider values of $D \\in [0.01, 1.0]$, $t \\in [0, 3.0]$ and fix $g=9.81$, $H=50.0$.\n", + "\n", + "If a GPU is available (for example you are working with Google Colab) we recomend to enable it beforehand." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch \n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 3.0\n", + "D_min, D_max = 0.01, 1.0\n", + "g, H = 9.81, 50.0\n", + "\n", + "# dataset size for training and testing (the batch size is the product of both) \n", + "N_D_train, N_t_train = 500, 50\n", + "N_D_test, N_t_test = 20, 50\n", + "\n", + "train_iterations = 5000\n", + "learning_rate = 1.e-3" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### a) Creating the Dataset\n", + "For the training of the neural network, we first need to create a fitting dataset. Create four tensors `input_training, output_training, input_testing, output_testing`. With shapes and data:\n", + "```\n", + "input_training.shape = [N_D_train, N_t_train, 2], output_training.shape = [N_D_train, N_t_train, 1] \n", + "```\n", + "```\n", + "input_training[i, k] = (D_i, t_k), output_training[i, k] = u(t_k; D_i)\n", + "```\n", + "Similar for the testing case. Here we want to sample $D$ randomly in our given interval (`torch.rand`) and use an equidistant grid for $t$ (`torch.linspace`). For the implementation of $u$, the functions `torch.exp, torch.sqrt` and `torch.log` are helpful. \n", + "\n", + "**Hint**: For inserting the $D$ values into the input-tensor, the methods `repeat_interleave` (repeats elements of a tensor) with the argument `N_t_train` and `reshape` (change the shape of a tensor) with the arguments `N_D_train, N_t_train` may be usefull." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Create and fill the tensors\n", + "# input_training = \n", + "# output_training = \n", + "# input_testing = \n", + "# output_testing = \n", + "\n", + "def u(t, D):\n", + " sqrt_term = torch.sqrt(D * g)\n", + " return H - 1/D * (torch.log((1 + torch.exp(-2*sqrt_term*t))/2.0) + sqrt_term*t)\n", + "\n", + "\n", + "input_training = torch.zeros((N_D_train, N_t_train, 2))\n", + "output_training = torch.zeros((N_D_train, N_t_train, 1))\n", + "\n", + "input_testing = torch.zeros((N_D_test, N_t_test, 2))\n", + "output_testing = torch.zeros((N_D_test, N_t_test, 1)) \n", + "\n", + "t_grid = torch.linspace(t_min, t_max, N_t_train)\n", + "D_values = D_min + (D_max - D_min) * torch.rand(N_D_train)\n", + "D_values_test = D_min + (D_max - D_min) * torch.rand(N_D_test)\n", + "\n", + "input_training[:, :, 0] = D_values.repeat_interleave(N_t_train).reshape(N_D_train, N_t_train)\n", + "input_training[:, :, 1] = t_grid\n", + "\n", + "input_testing[:, :, 0] = D_values_test.repeat_interleave(N_t_test).reshape(N_D_test, N_t_test)\n", + "input_testing[:, :, 1] = t_grid\n", + "\n", + "output_training[:, :, 0] = u(input_training[:, :, 1], input_training[:, :, 0])\n", + "output_testing[:, :, 0] = u(input_testing[:, :, 1], input_testing[:, :, 0])\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### b) Defining the Neural Network\n", + "In the next step, we define our neural network, which approximates the function. For this, we can utilize \n", + "PyTorch pre-implemented building blocks:\n", + "\n", + " - `torch.nn.Linear`: One single fully connected layer. Constructed with the number of inputs and outputs\n", + " features. \n", + " - `torch.nn.ReLU` and `torch.nn.Tanh`: Possible activation functions.\n", + " - `torch.nn.Sequential`: Sequentially evaluates the building blocks to create larger and more complex neural networks. Example: `torch.nn.Sequential(torch.nn.Linear(10, 15), torch.nn.Linear(15, 5), torch.nn.ReLU())`\n", + "\n", + "Build a network that has 2 input neurons for the values of $t, D$ and 1 output neuron for $u$, two hidden layers of size 20 and me as activations in between." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: implement the neural network\n", + "# model =\n", + "\n", + "model = torch.nn.Sequential(\n", + " torch.nn.Linear(2, 20), torch.nn.Tanh(), \n", + " torch.nn.Linear(20, 20), torch.nn.Tanh(), \n", + " torch.nn.Linear(20, 1)\n", + ") " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### c) Writting the Training Loop\n", + "The last step is to create the training loop, where the neural network learns from the data.\n", + "The desired loss function and the optimizer we want to use are already pre-defined. Your task is to implement the missing steps inside the loop (e.g. evaluation of the model, computing the loss, and doing the optimization). \n", + "The example implementation on the [Pytorch page](https://pytorch.org/tutorials/beginner/pytorch_with_examples.html#pytorch-optim) can be very helpful for this task.\n", + "\n", + "Once you have finished the implementation, run all the cells and start the training. You can also run the below cell multiple times to further tune the neural network. At the end of the notebook, you can check the accuracy of the model." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loss at iteration 0 / 5000 is 27.970970\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loss at iteration 249 / 5000 is 27.958805\n", + "Loss at iteration 499 / 5000 is 27.958416\n", + "Loss at iteration 749 / 5000 is 2.177030\n", + "Loss at iteration 999 / 5000 is 0.083997\n", + "Loss at iteration 1249 / 5000 is 0.017167\n", + "Loss at iteration 1499 / 5000 is 0.007438\n", + "Loss at iteration 1749 / 5000 is 0.004969\n", + "Loss at iteration 1999 / 5000 is 0.003936\n", + "Loss at iteration 2249 / 5000 is 0.003399\n", + "Loss at iteration 2499 / 5000 is 0.003055\n", + "Loss at iteration 2749 / 5000 is 0.002793\n", + "Loss at iteration 2999 / 5000 is 0.002571\n", + "Loss at iteration 3249 / 5000 is 0.002376\n", + "Loss at iteration 3499 / 5000 is 0.002196\n", + "Loss at iteration 3749 / 5000 is 0.002039\n", + "Loss at iteration 3999 / 5000 is 0.001882\n", + "Loss at iteration 4249 / 5000 is 0.001732\n", + "Loss at iteration 4499 / 5000 is 0.001333\n", + "Loss at iteration 4749 / 5000 is 0.001198\n", + "Loss at iteration 4999 / 5000 is 0.001086\n" + ] + } + ], + "source": [ + "### Move data to GPU\n", + "model.to(\"cuda\")\n", + "input_training = input_training.to(\"cuda\")\n", + "output_training = output_training.to(\"cuda\")\n", + "\n", + "### For the loss, we take the mean squared error and Adam for optimization.\n", + "loss_fn = torch.nn.MSELoss() \n", + "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n", + "\n", + "### Training loop\n", + "for t in range(train_iterations):\n", + " ### TODO: Model evaluation, loss computation and optimization\n", + " model_out = model(input_training)\n", + "\n", + " loss = loss_fn(model_out, output_training)\n", + "\n", + " ### Shows current loss every 250 iterations:\n", + " if t == 0 or (t+1) % 250 == 0:\n", + " print(\"Loss at iteration %i / %i is %f\" %(t, train_iterations, loss.item()))\n", + "\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Relative error on the test data is: tensor(0.0040, grad_fn=)\n", + "Showing D value: 0.8410727977752686\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Here, we preimplemented a check of the accruarcy of the model with the training set and a plot of \n", + "### the solution for a given data set:\n", + "data_index_for_plot = 0\n", + "\n", + "### First compute error:\n", + "model.to(\"cpu\")\n", + "model_out = model(input_testing)\n", + "error = torch.abs(model_out - output_testing)\n", + "print(\"Relative error on the test data is:\", torch.max(error) / torch.max(output_testing))\n", + "\n", + "### Plot solution\n", + "import matplotlib.pyplot as plt\n", + "print(\"Showing D value:\", input_testing[data_index_for_plot, 0, 0].item())\n", + "plt.figure(0, figsize=(15, 5))\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(input_testing[data_index_for_plot, :, 1], model_out[data_index_for_plot].detach())\n", + "plt.title(\"Neural Network\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(input_testing[data_index_for_plot, :, 1], output_testing[data_index_for_plot])\n", + "plt.title(\"Reference Solution\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(input_testing[data_index_for_plot, :, 1], error[data_index_for_plot].detach())\n", + "plt.title(\"Absolute Difference\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/Sol1_3.ipynb b/examples/workshop/Sol1_3.ipynb new file mode 100644 index 00000000..45ae42e7 --- /dev/null +++ b/examples/workshop/Sol1_3.ipynb @@ -0,0 +1,387 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 1\n", + "\n", + "#### 1.3 Physics-informed function approximation \n", + "Previously we used a dataset to learn solutions of the ODE:\n", + "\\begin{align*}\n", + " \\partial_t^2 u(t) &= D(\\partial_t u(t))^2 - g \\\\\n", + " u(0) &= H \\\\\n", + " \\partial_t u(0) &= 0\n", + "\\end{align*}\n", + "Now, we assume that the solution is not analytically known. Therefore we have to utilize the above differential equation in the training, which leads us to physics-informed neural networks.\n", + "\n", + "For simplification of the implementation, we start with a fixed value for $D=0.02$." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch \n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 3.0\n", + "D = 0.02\n", + "g, H = 9.81, 50.0\n", + "\n", + "# number of time points \n", + "N_t = 50\n", + "\n", + "train_iterations = 5000\n", + "learning_rate = 1.e-3" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the physics-informed training, the derivatives of the neural network have to be comupted. For this, we can use `torch.autograd.grad` (automatic differentiation). With `torch.autograd.grad` not only the gradients of neural networks can be computed but also the derivatives of general tensor operations. Here a small example for $t^2$:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Derivative with autograd gives:\n", + "tensor([ 0., 2., 4., 6., 8., 10., 12., 14., 16., 18., 20.],\n", + " grad_fn=)\n", + "Analytical derivative is:\n", + "tensor([ 0., 2., 4., 6., 8., 10., 12., 14., 16., 18., 20.],\n", + " grad_fn=)\n", + "They are in agreement!\n" + ] + } + ], + "source": [ + "# Create some data points\n", + "t = torch.linspace(0, 10, 11, requires_grad=True) # we need to set requires_grad=True, or else\n", + " # PyTorch will not be able to compute derivatives\n", + "u = t**2 # compute the square of the values\n", + "# Next up, we have to take the sum over all our values to compute the derivative. This has to do \n", + "# with the implementation in PyTorch and we just have to remember to it.\n", + "# (the reason why is yet not so important)\n", + "u_sum = sum(u)\n", + "# Now we can call torch.autograd.grad:\n", + "u_t = torch.autograd.grad(u_sum, t, create_graph=True) # create_graph=True has to be set, so one can \n", + " # later compute derivatives of higher order\n", + "# Autograd generally returns a tuple with multiple values, here we only need the first one:\n", + "print(\"Derivative with autograd gives:\")\n", + "print(u_t[0])\n", + "print(\"Analytical derivative is:\")\n", + "print(2*t)\n", + "print(\"They are in agreement!\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### a) Working with `torch.autograd.grad`\n", + "Verify, with the help of `torch.autograd.grad`, that the previously given function\n", + "\\begin{align*}\n", + " u(t; D) &= \\frac{1}{D} \\left(\\ln{\\left( \\frac{1+e^{-2\\sqrt{Dg}t}}{2} \\right)} - \\sqrt{Dg} t \\right) + H\n", + "\\end{align*}\n", + "really solves the above ODE (e.g. numerically compute the derivatives and insert them into the ODE).\n", + "\n", + "**Hint** : `torch.sqrt` only works for tensor-objects, you habe to either transform $D, g$ into tensors or import the `math` package for the root computation. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([ 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 9.5367e-07,\n", + " -9.5367e-07, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n", + " -9.5367e-07, -9.5367e-07, 0.0000e+00, 9.5367e-07, -9.5367e-07,\n", + " 0.0000e+00, -9.5367e-07, -9.5367e-07, -9.5367e-07, -9.5367e-07,\n", + " -9.5367e-07, 0.0000e+00, -9.5367e-07, 0.0000e+00, 0.0000e+00,\n", + " -9.5367e-07, -9.5367e-07, 0.0000e+00, -9.5367e-07, 0.0000e+00,\n", + " -9.5367e-07, 0.0000e+00, -9.5367e-07, 0.0000e+00, -9.5367e-07,\n", + " -9.5367e-07, -9.5367e-07, -9.5367e-07, -9.5367e-07, -9.5367e-07,\n", + " -9.5367e-07, -9.5367e-07, 0.0000e+00, -9.5367e-07, -9.5367e-07,\n", + " -9.5367e-07, 0.0000e+00, 0.0000e+00, 0.0000e+00, -9.5367e-07],\n", + " grad_fn=)\n" + ] + } + ], + "source": [ + "import math\n", + "t = torch.linspace(t_min, t_max, N_t, requires_grad=True)\n", + "\n", + "sqrt_term = math.sqrt(D * g)\n", + "u = H - 1/D * (torch.log((1 + torch.exp(-2*sqrt_term*t))/2.0) + sqrt_term*t)\n", + "\n", + "u_t = torch.autograd.grad(sum(u), t, create_graph=True)[0]\n", + "u_tt = torch.autograd.grad(sum(u_t), t, create_graph=True)[0]\n", + "\n", + "print(u_tt - D*u_t**2 + g)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the following cell, the time grid, a tensor for the initial time point and the neural network is given:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "t = torch.linspace(t_min, t_max, N_t, requires_grad=True).reshape(N_t, 1)\n", + "t_zero = torch.tensor([0.0], requires_grad=True)\n", + "\n", + "model = torch.nn.Sequential(\n", + " torch.nn.Linear(1, 20), torch.nn.Tanh(), \n", + " torch.nn.Linear(20, 20), torch.nn.Tanh(), \n", + " torch.nn.Linear(20, 1)\n", + ") " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### b) Implementing the physics-informed Loss\n", + "Use `torch.autograd.grad` to complete the training loop, by implementing the loss for the differential equation and both initial conditions.\n", + "\n", + "Each condition needs it own loss function, which are already prepared at the top of the cell." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loss at iteration 0 / 5000 is 0.001201\n", + "Loss at iteration 250 / 5000 is 0.000000\n", + "Loss at iteration 500 / 5000 is 0.000000\n", + "Loss at iteration 750 / 5000 is 0.000000\n", + "Loss at iteration 1000 / 5000 is 0.000000\n", + "Loss at iteration 1250 / 5000 is 0.000000\n", + "Loss at iteration 1500 / 5000 is 0.000000\n", + "Loss at iteration 1750 / 5000 is 0.000000\n", + "Loss at iteration 2000 / 5000 is 0.000000\n", + "Loss at iteration 2250 / 5000 is 0.000000\n", + "Loss at iteration 2500 / 5000 is 0.000000\n", + "Loss at iteration 2750 / 5000 is 0.000000\n", + "Loss at iteration 3000 / 5000 is 0.000000\n", + "Loss at iteration 3250 / 5000 is 0.000000\n", + "Loss at iteration 3500 / 5000 is 0.000000\n", + "Loss at iteration 3750 / 5000 is 0.000000\n", + "Loss at iteration 4000 / 5000 is 0.000000\n", + "Loss at iteration 4250 / 5000 is 0.000000\n", + "Loss at iteration 4500 / 5000 is 0.000000\n", + "Loss at iteration 4750 / 5000 is 0.000000\n", + "Loss at iteration 4999 / 5000 is 0.000000\n" + ] + } + ], + "source": [ + "model.to(\"cuda\")\n", + "t = t.to(\"cuda\")\n", + "t_zero = t_zero.to(\"cuda\")\n", + "\n", + "### For the loss, we take the mean squared error and Adam for optimization.\n", + "loss_fn_ode = torch.nn.MSELoss() \n", + "loss_fn_initial_position = torch.nn.MSELoss() \n", + "loss_fn_initial_speed = torch.nn.MSELoss() \n", + "\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n", + "\n", + "### Training loop\n", + "for k in range(train_iterations):\n", + " ### TODO: implement loss computation of all equations\n", + " ### Loss for the differential equation: u_tt = D*(u_t)^2 - g\n", + " u = model(t)\n", + " u_t = torch.autograd.grad(sum(u), t, create_graph=True)[0]\n", + " u_tt = torch.autograd.grad(sum(u_t), t, create_graph=True)[0]\n", + "\n", + " ode = u_tt - D*u_t**2 + g\n", + "\n", + " loss_ode = loss_fn_ode(ode, torch.zeros_like(ode))\n", + "\n", + " ### Loss for initial condition: u(0) = H\n", + " u_zero = model(t_zero) - H\n", + " loss_initial_position = loss_fn_initial_position(u_zero, torch.zeros_like(u_zero))\n", + "\n", + " ### Loss for the initial velocity: u_t(0) = 0\n", + " u_zero_t = torch.autograd.grad(u_zero, t_zero, create_graph=True)[0]\n", + " loss_initial_speed = loss_fn_initial_speed(u_zero_t, torch.zeros_like(u_zero_t))\n", + "\n", + " ### Add all loss terms\n", + " total_loss = loss_ode + loss_initial_position + loss_initial_speed\n", + "\n", + " ### Shows current loss every 250 iterations:\n", + " if k % 250 == 0 or k == train_iterations - 1:\n", + " print(\"Loss at iteration %i / %i is %f\" %(k, train_iterations, total_loss.item()))\n", + "\n", + " ### Optimization step\n", + " optimizer.zero_grad()\n", + " total_loss.backward()\n", + " optimizer.step()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import math\n", + "### Here, a check of the accruarcy of the model:\n", + "t_plot = torch.linspace(t_min, t_max, 1000).reshape(-1, 1)\n", + "\n", + "### First compute error:\n", + "model.to(\"cpu\")\n", + "model_out = model(t_plot)\n", + "\n", + "sqrt_term = math.sqrt(D * g)\n", + "real_out = H - 1/D * (torch.log((1 + torch.exp(-2*sqrt_term*t_plot))/2.0) + sqrt_term*t_plot)\n", + "\n", + "### Plot solution\n", + "import matplotlib.pyplot as plt\n", + "plt.figure(0, figsize=(15, 5))\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(t_plot, model_out.detach())\n", + "plt.title(\"Neural Network\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(t_plot, real_out)\n", + "plt.title(\"Reference Solution\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(t_plot, torch.abs(real_out - model_out).detach())\n", + "plt.title(\"Absolute Difference\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "### Implementation for FDM:\n", + "\n", + "# t = torch.linspace(t_min, t_max, 500).reshape(500, 1)\n", + "# t_zero = torch.tensor([0.0])\n", + "\n", + "\n", + "# model.to(\"cuda\")\n", + "# t = t.to(\"cuda\")\n", + "# t_zero = t_zero.to(\"cuda\")\n", + "\n", + "# dt = t[1] - t[0] # step width\n", + "# t_delta = torch.tensor([dt], device=\"cuda\")\n", + "\n", + "\n", + "# ### For the loss, we take the mean squared error and Adam for optimization.\n", + "# loss_fn_ode = torch.nn.MSELoss() \n", + "# loss_fn_initial_position = torch.nn.MSELoss() \n", + "# loss_fn_initial_speed = torch.nn.MSELoss() \n", + "\n", + "# optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n", + "\n", + "# ### Training loop\n", + "# for k in range(train_iterations):\n", + "# ### TODO: implement loss computation of all equations\n", + "# ### Loss for the differential equation: u_tt = D*(u_t)^2 - g\n", + "# u = model(t)\n", + "# u_t = (u[1:-1] - u[2:])\n", + "# u_tt = (u[:-2] - 2*u[1:-1] + u[2:])\n", + "\n", + "# ode = u_tt - D*u_t**2 + g * dt**2\n", + "\n", + "# loss_ode = loss_fn_ode(ode, torch.zeros_like(ode))\n", + "\n", + "# ### Loss for initial condition: u(0) = H\n", + "# u_zero = model(t_zero)\n", + "# loss_initial_position = loss_fn_initial_position(u_zero - H, torch.zeros_like(u_zero))\n", + "\n", + "# ### Loss for the initial velocity: u_t(0) = 0\n", + "# u_delta_t = model(t_delta)\n", + "# loss_initial_speed = loss_fn_initial_speed((u_delta_t - u_zero), torch.zeros_like(u_zero))\n", + "\n", + "# ### Add all loss terms\n", + "# total_loss = loss_ode + loss_initial_position + loss_initial_speed\n", + "\n", + "# ### Shows current loss every 250 iterations:\n", + "# if k % 250 == 0 or k == train_iterations - 1:\n", + "# print(\"Loss at iteration %i / %i is %f\" %(k, train_iterations, total_loss.item()))\n", + "\n", + "# ### Optimization step\n", + "# optimizer.zero_grad()\n", + "# total_loss.backward()\n", + "# optimizer.step()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/Sol2_1.ipynb b/examples/workshop/Sol2_1.ipynb new file mode 100644 index 00000000..de2c9d43 --- /dev/null +++ b/examples/workshop/Sol2_1.ipynb @@ -0,0 +1,300 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 2\n", + "\n", + "#### 2.1 Solving a ODE with TorchPhysics\n", + "Use TorchPhysics to solve the ODE for falling with a parachute:\n", + "\\begin{align*}\n", + " \\partial_t^2 u(t) &= D(\\partial_t u(t))^2 - g \\\\\n", + " u(0) &= H \\\\\n", + " \\partial_t u(0) &= 0\n", + "\\end{align*}\n", + "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell. Since the installation can take around 2 minutes and has to be redone if you switch to the GPU later." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl\n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 3.0\n", + "D_min, D_max = 0.01, 1.0\n", + "g, H = 9.81, 50.0\n", + "\n", + "# number of time points \n", + "N_t = 5000\n", + "N_initial = 100\n", + "\n", + "train_iterations = 5000\n", + "learning_rate = 1.e-3" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the [lecture example](https://github.com/TomF98/torchphysics/tree/main/examples) gives a good guide for working with TorchPhysics." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Implement the spaces\n", + "T = tp.spaces.R1('t')\n", + "U = tp.spaces.R1('u')\n", + "D = tp.spaces.R1('D')\n", + "### TODO: Define the time interval \n", + "int_t = tp.domains.Interval(T, t_min, t_max)\n", + "int_D = tp.domains.Interval(D, D_min, D_max)\n", + "### TODO: Create sampler for points inside and at the left boundary\n", + "ode_sampler = tp.samplers.RandomUniformSampler(int_t*int_D, n_points=N_t)\n", + "initial_sampler = tp.samplers.RandomUniformSampler(int_t.boundary_left*int_D, n_points=N_initial)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Create neural network\n", + "model = tp.models.FCN(T*D, U, hidden=(20, 20))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the ODE:\n", + "def ode_residual(u, t, D):\n", + " u_t = tp.utils.grad(u, t)\n", + " u_tt = tp.utils.grad(u_t, t)\n", + " return u_tt - D*u_t**2 + g\n", + "\n", + "ode_condition = tp.conditions.PINNCondition(model, ode_sampler, ode_residual)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the initial position:\n", + "def position_residual(u):\n", + " return u - H\n", + "\n", + "initial_position_condition = tp.conditions.PINNCondition(model, initial_sampler, position_residual)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the initial velocity:\n", + "def velocity_residual(u, t):\n", + " return tp.utils.grad(u, t)\n", + "\n", + "initial_velocity_condition = tp.conditions.PINNCondition(model, initial_sampler, velocity_residual)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 501 \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "501 Trainable params\n", + "0 Non-trainable params\n", + "501 Total params\n", + "0.002 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a9eb39dd8f8c4a4a85fa07fc94ac43cf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ffcabe489dab41b6a05ebe4abb55f1b6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### Syntax for the training is already implemented:\n", + "\n", + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate) \n", + "solver = tp.solver.Solver([ode_condition, initial_position_condition, initial_velocity_condition],\n", + " optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus=1, # or None on a CPU\n", + " benchmark=True,\n", + " max_steps=train_iterations,\n", + " logger=False\n", + " )\n", + "\n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'absolute error')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Here, plot the solution and the error:\n", + "import matplotlib.pyplot as plt\n", + "D_test = 0.08\n", + "\n", + "def analytic_solution(t, D):\n", + " return 1/D * (-torch.log((1+torch.exp(-2*torch.sqrt(D*g)*t))/2) - torch.sqrt(D*g)*t) + H\n", + "\n", + "plot_sampler = tp.samplers.PlotSampler(int_t, 100, data_for_other_variables={'D': D_test})\n", + "fig = tp.utils.plot(model, lambda u: u, plot_sampler)\n", + "plt.title(\"computed solution\")\n", + "\n", + "plot_sampler = tp.samplers.PlotSampler(int_t, 100, data_for_other_variables={'D': D_test})\n", + "fig = tp.utils.plot(model, lambda t,D: analytic_solution(t, D), plot_sampler)\n", + "plt.title(\"analytical solution\")\n", + "\n", + "fig = tp.utils.plot(model, lambda u,t,D: torch.abs(u - analytic_solution(t, D)), plot_sampler)\n", + "plt.title(\"absolute error\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/Sol2_2.ipynb b/examples/workshop/Sol2_2.ipynb new file mode 100644 index 00000000..e75a7a8d --- /dev/null +++ b/examples/workshop/Sol2_2.ipynb @@ -0,0 +1,383 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 2\n", + "\n", + "#### 2.2 Solving a PDE with TorchPhysics\n", + "Use TorchPhysics to solve the following heat equation:\n", + "\n", + "\\begin{align*}\n", + "{\\partial_t} u(x,t) &= \\Delta_x u(x,t) &&\\text{ on } \\Omega\\times I, \\\\\n", + "u(x, t) &= u_0 &&\\text{ on } \\Omega\\times \\{0\\},\\\\\n", + "u(x,t) &= h(t) &&\\text{ at } \\partial\\Omega_{heater}\\times I, \\\\\n", + "\\nabla_x u(x, t) \\cdot \\overset{\\rightarrow}{n}(x) &= 0 &&\\text{ at } (\\partial \\Omega \\setminus \\partial\\Omega_{heater}) \\times I.\n", + "\\end{align*}\n", + "\n", + "The above system describes an isolated room $\\Omega$, with a \\\\\n", + "heater at the wall $\\partial\\Omega_{Heater} = \\{(x, y) | 1\\leq x\\leq 3, y=4\\}$. We set $I=[0, 20]$, $D=1$, the initial temperature to $u_0 = 16$\\,\\degree C and the temperature of the heater is defined below.\n", + "\n", + "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell. Since the installation can take around 2 minutes and has to be redone if you switch to the GPU later." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "###!pip install torchphysics" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 20.0\n", + "width, height = 5.0, 4.0\n", + "D = 1.0\n", + "u_0 = 16 # initial temperature\n", + "u_heater_max = 40 # maximal temperature of the heater\n", + "t_heater_max = 5 # time at which the heater reaches its maximal temperature\n", + "\n", + "# Heater temperature function\n", + "def h(t):\n", + " ht = u_0 + (u_heater_max - u_0) / t_heater_max * t\n", + " ht[t>t_heater_max] = u_heater_max\n", + " return ht\n", + "\n", + "# Visualize h(t)\n", + "t = torch.linspace(0, 20, 200)\n", + "plt.plot(t, h(t))\n", + "plt.grid()\n", + "plt.title(\"temperature of the heater over time\")\n", + "\n", + "# Number of time points \n", + "N_pde = 15000\n", + "N_initial = 5000\n", + "N_boundary = 5000\n", + "\n", + "# Training parameters\n", + "train_iterations = 5000\n", + "learning_rate = 1.e-3" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We would recommend trying implementing the following steps by yourself (and/or together with your colleagues). \n", + "\n", + "But if you need more guidance for TorchPhysics, a heat equation example is shown in this [notebook](https://github.com/TomF98/torchphysics/blob/main/examples/pinn/heat-equation.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Implement the spaces\n", + "X = tp.spaces.R2('x')\n", + "T = tp.spaces.R1('t')\n", + "U = tp.spaces.R1('u')\n", + "\n", + "### TODO: Define the domain omega and time interval \n", + "Omega = tp.domains.Parallelogram(space=X, origin=[0,0], corner_1=[width,0], corner_2=[0,height])\n", + "I = tp.domains.Interval(space=T, lower_bound=t_min, upper_bound=t_max)\n", + "\n", + "### TODO: Create sampler for inside Omega x I, for the initial condition in Omega x {0} and on the \n", + "### boundary \\partial Omega x I\n", + "pde_sampler = tp.samplers.RandomUniformSampler(domain=Omega*I, n_points=N_pde)\n", + "initial_sampler = tp.samplers.RandomUniformSampler(domain=Omega*I.boundary_left, n_points=N_initial)\n", + "boundary_sampler = tp.samplers.RandomUniformSampler(domain=Omega.boundary*I, n_points=N_boundary)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# One can check if the points are sampled in the correct way:\n", + "plot = tp.utils.scatter(Omega.space*I.space, pde_sampler, initial_sampler, boundary_sampler)\n", + "# Some times the perspective is somewhat strang in the plot, but generally one should see:\n", + "# - blue = points inside the domain Omega x I\n", + "# - orange = points at the bottom, for Omega x {0}\n", + "# - green = points at sides, for \\partial Omega x I " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Create the neural network with 3 hidden layers and 50 neurons each.\n", + "model = tp.models.FCN(input_space=X*T, output_space=U, hidden = (50,50,50))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the PDE:\n", + "# Use tp.utils.laplacian and tp.utils.grad to compute all needed derivatives\n", + "def pde_residual(u, t, x):\n", + " return tp.utils.laplacian(u, x) - tp.utils.grad(u, t)\n", + "\n", + "pde_condition = tp.conditions.PINNCondition(model, pde_sampler, pde_residual)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the initial temperature:\n", + "def initial_residual(u):\n", + " return u - u_0\n", + "\n", + "initial_condition = tp.conditions.PINNCondition(model, initial_sampler, initial_residual)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the boundary conditions:\n", + "### Already implemented is a filltering, to determine on what part the points are\n", + "### on the boundary, and the normal vector computation.\n", + "### For the normal derivative use: tp.utils.normal_derivative\n", + "def boundary_residual(u, t, x):\n", + " # Create boolean tensor indicating which points x belong to the dirichlet condition (heater location)\n", + " heater_location = (x[:, 0] >= 1) & (x[:, 0] <= 3) & (x[:, 1] >= 3.99) \n", + " # Normal vectors of the domain Omega\n", + " normal_vectors = Omega.boundary.normal(x)\n", + "\n", + " residual = tp.utils.normal_derivative(u, normal_vectors, x)\n", + " residual[heater_location] = (u - h(t))[heater_location]\n", + " return residual\n", + "\n", + "boundary_condition = tp.conditions.PINNCondition(model, boundary_sampler, boundary_residual)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 5.4 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "5.4 K Trainable params\n", + "0 Non-trainable params\n", + "5.4 K Total params\n", + "0.021 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "815b926a58934870815ce08270679b62", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3e6fb399bca74853bdef428c1ab1d746", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0591ca91a014434389d22e47d5987ab0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Start the training\n", + "training_conditions = [pde_condition, initial_condition, boundary_condition]\n", + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate)\n", + "solver = tp.solver.Solver(train_conditions=training_conditions, optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", + " max_steps=train_iterations, # number of training steps\n", + " logger=False,\n", + " benchmark=True, \n", + " enable_checkpointing=False)\n", + "\n", + "trainer.fit(solver) # run the training loop" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the solution at some point in time\n", + "time_point = 2.0\n", + "\n", + "plot_sampler = tp.samplers.PlotSampler(plot_domain=Omega, n_points=1000, \n", + " data_for_other_variables={'t':time_point}) # <- input that is fixed for the plot\n", + "fig = tp.utils.plot(model=model, plot_function=lambda u : u, point_sampler=plot_sampler, angle=[30, 220])" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "MovieWriter ffmpeg unavailable; using Pillow instead.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# We can also animate the solution over time\n", + "anim_sampler = tp.samplers.AnimationSampler(Omega, I, 200, n_points=1000)\n", + "fig, anim = tp.utils.animate(model, lambda u: u, anim_sampler, ani_speed=10, angle=[30, 220])\n", + "anim.save('heat-eq.gif')\n", + "# On Google colab you have at the left side a tab with a folder. There you should find the gif and watch it." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/workshop_example.ipynb b/examples/workshop/workshop_example.ipynb deleted file mode 100644 index 61556f04..00000000 --- a/examples/workshop/workshop_example.ipynb +++ /dev/null @@ -1,409 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n", - "import torch\n", - "import torchphysics as tp\n", - "import pytorch_lightning as pl" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([[[18.5000+0.0000j, -3.5000+1.0000j, -7.5000+0.0000j],\n", - " [-3.5000+2.0000j, 1.0000+0.5000j, 2.5000-2.0000j],\n", - " [-1.5000+0.0000j, 0.5000+0.0000j, 0.5000+0.0000j],\n", - " [-3.5000-2.0000j, 0.0000+0.5000j, 2.5000+2.0000j]],\n", - "\n", - " [[15.5000+0.0000j, -3.7500+2.7500j, -5.0000+0.0000j],\n", - " [-0.5000+4.0000j, 1.2500+1.2500j, -0.5000-3.5000j],\n", - " [-0.5000+0.0000j, 0.7500+1.2500j, 0.0000+0.0000j],\n", - " [-0.5000-4.0000j, -0.2500+0.7500j, -0.5000+3.5000j]]]) torch.Size([2, 4, 4]) torch.Size([2, 4, 3])\n", - "tensor([[[ 4.0000+0.j, -2.0000+0.j],\n", - " [-1.0000+0.j, 1.0000+0.j]],\n", - "\n", - " [[ 1.5000+0.j, -0.5000+0.j],\n", - " [ 1.5000+0.j, -0.5000+0.j]]])\n" - ] - } - ], - "source": [ - "x = torch.tensor((2, 4))\n", - "a = torch.tensor([[[1, 2, 3, 4], [1, 4, 5, 6], [1, 9, 5, 9], [1, 9, 5, 9]], \n", - " [[1, 2, 3, 8], [0, 0, 5, 3], [1, 4, 5, 6], [1, 9, 5, 9]]])\n", - "padding = torch.zeros(2*len(x), dtype=torch.int32)\n", - "padding[1::2] = torch.flip(torch.floor((x - torch.tensor(a.shape[1:])) / 2.0), \n", - " dims=(0,))\n", - "fft = torch.fft.rfftn(a, dim=(1, 2), norm=\"ortho\")\n", - "print(fft, a.shape, fft.shape)\n", - "fft = torch.fft.rfft2(a, s=(2, 2), norm=\"ortho\")\n", - "print(fft)\n", - "#fft_split = torch.fft.fft(torch.fft.fft(a, dim=2), dim=1)\n", - "#print(torch.abs(fft_split - fft))\n", - "#fft = torch.nn.functional.pad(\n", - "# torch.fft.rfftn(a, dim=(-1, -2), norm=\"ortho\"), \n", - "# padding.tolist()) # here remove to high freq.\n", - "#print(padding, fft.shape)\n", - "#print((torch.nn.functional.pad(fft, (-padding).tolist())).shape)\n", - "#weighted_fft = fft\n", - "#ifft = torch.fft.irfftn(\n", - "# torch.nn.functional.pad(weighted_fft, (-padding).tolist()), # here add high freq.\n", - "# dim=(-1, -2), norm=\"ortho\")\n", - "#ifft" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([ 0, -1, 0, -1], dtype=torch.int32) tensor([[[ 2.1213+0.j, -0.7071+0.j]],\n", - "\n", - " [[ 2.1213+0.j, -0.7071+0.j]]])\n", - "tensor([[[19.9006+0.0000j, -5.8753+1.0731j, -1.7928-1.7364j],\n", - " [ 0.1826+2.5298j, 1.7317+2.6037j, 0.9396+0.0542j],\n", - " [ 0.1826-2.5298j, 0.1402+2.9430j, -2.5377+1.4542j]],\n", - "\n", - " [[ 1.6432+0.0000j, 0.2257-1.8690j, -0.5908-1.6350j],\n", - " [-2.7386+0.0000j, 0.6699-0.6000j, 0.7145+1.0904j],\n", - " [-2.7386+0.0000j, 0.3691-0.3815j, 0.5286+1.6625j]]])\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor([[[0.1826, 0.4349, 0.8431, 0.8431, 0.4349],\n", - " [0.1826, 0.4349, 0.8431, 0.8431, 0.4349],\n", - " [0.1826, 0.4349, 0.8431, 0.8431, 0.4349]],\n", - "\n", - " [[0.1826, 0.4349, 0.8431, 0.8431, 0.4349],\n", - " [0.1826, 0.4349, 0.8431, 0.8431, 0.4349],\n", - " [0.1826, 0.4349, 0.8431, 0.8431, 0.4349]]])" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "x = torch.tensor((1, 2))\n", - "a = torch.tensor([[[1, 2, 3, 4, 5], [1, 4, 5, 6, 2], [1, 9, 5, 9, 2]], \n", - " [[1, 2, 3, 8, 8], [0, 0, 5, 3, 2], [1, 4, 5, 6, 2]]])\n", - "padding = torch.zeros(2*len(x), dtype=torch.int32)\n", - "padding[1::2] = torch.flip((x - torch.tensor(a.shape[1:])), \n", - " dims=(0,)) / 2\n", - "fft = torch.fft.rfftn(a, s=x.tolist(), norm=\"ortho\") \n", - "print(padding, fft)\n", - "print(torch.fft.rfftn(a, norm=\"ortho\") )\n", - "weighted_fft = fft\n", - "ifft = torch.fft.irfftn(fft, s=(3, 5), norm=\"ortho\")\n", - "ifft" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "a = torch.ones((5, 4, 100, 10))" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([[0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n", - " 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n", - " 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n", - " 0.0000e+00, 0.0000e+00],\n", - " [6.1426e-09, 3.0781e-08, 1.1931e-07, 1.1947e-07, 1.7126e-08, 1.7883e-07,\n", - " 7.9779e-10, 5.9652e-08, 6.1000e-08, 2.9829e-08, 2.1280e-08, 8.3902e-09,\n", - " 5.9777e-08, 6.0192e-08, 1.7875e-09, 1.2602e-09, 1.4750e-08, 5.9639e-08,\n", - " 5.9693e-08, 2.9871e-08]])" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a = torch.ones((2, 20))\n", - "a[1, :] = torch.sin(torch.linspace(0, 6, 20))\n", - "b = torch.fft.fftn(a, dim=1, norm=\"ortho\")\n", - "torch.abs(torch.fft.ifftn(b, dim=1, norm=\"ortho\") - a)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "t_end = 3.0\n", - "D_min, D_max = 0.01, 1.0\n", - "g = 9.81\n", - "H = 50.0" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "T = tp.spaces.R1('t')\n", - "D = tp.spaces.R1('D')\n", - "X = tp.spaces.R1('x')\n", - "\n", - "int_t = tp.domains.Interval(T, 0, t_end)\n", - "int_D = tp.domains.Interval(D, D_min, D_max)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "model = tp.models.FCN(T*D, X, hidden=(20, 20))" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def ode_residual(x, t, D):\n", - " #x *= 50.0\n", - " x_t = tp.utils.grad(x, t)\n", - " #x_tt = tp.utils.grad(x_t, t)\n", - " return x_t - D * x**2 + g\n", - "\n", - "ode_sampler = tp.samplers.RandomUniformSampler(int_t * int_D, n_points=5000)\n", - "\n", - "ode_condition = tp.conditions.PINNCondition(model, ode_sampler, ode_residual)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "def initial_residual(x):\n", - " x *= 50.0\n", - " return x - H\n", - "\n", - "initial_sampler = tp.samplers.RandomUniformSampler(int_t.boundary_left * int_D, 500)\n", - "\n", - "initial_condition = tp.conditions.PINNCondition(model, initial_sampler, initial_residual)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def initial_residual_v(x, t):\n", - " #x *= 50.0\n", - " #x_t = tp.utils.grad(x, t)\n", - " return x # x_t\n", - "\n", - "initial_condition_v = tp.conditions.PINNCondition(model, initial_sampler, initial_residual_v)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True, used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [1]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 501 \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "501 Trainable params\n", - "0 Non-trainable params\n", - "501 Total params\n", - "0.002 Total estimated model params size (MB)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8d27b61e25b04e89ab7e01d9fe22061b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "00e5b06b3e544f6da68bbaeef5a29174", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.001) \n", - "solver = tp.solver.Solver([ode_condition, initial_condition_v],\n", - " optimizer_setting=optim)\n", - "\n", - "trainer = pl.Trainer(gpus=1,\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=7500,\n", - " logger=False,\n", - " checkpoint_callback=False\n", - " )\n", - "\n", - "trainer.fit(solver)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'absolute error')" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "D_test = 0.08\n", - "\n", - "def analytic_solution(t, D):\n", - " return torch.sqrt(g / D) * (2/(1 + torch.exp(2*torch.sqrt(D*g)*t)) - 1)\n", - " #return 1/D * (-torch.log((1+torch.exp(-2*torch.sqrt(D*g)*t))/2) - torch.sqrt(D*g)*t) + H\n", - "\n", - "plot_sampler = tp.samplers.PlotSampler(int_t, 100, data_for_other_variables={'D': D_test})\n", - "fig = tp.utils.plot(model, lambda x: x, plot_sampler)\n", - "plt.title(\"computed solution\")\n", - "\n", - "plot_sampler = tp.samplers.PlotSampler(int_t, 100, data_for_other_variables={'D': D_test})\n", - "fig = tp.utils.plot(model, lambda t,D: analytic_solution(t, D), plot_sampler)\n", - "plt.title(\"analytical solution\")\n", - "\n", - "fig = tp.utils.plot(model, lambda x,t,D: torch.abs(x - analytic_solution(t, D)), plot_sampler)\n", - "plt.title(\"absolute error\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "bosch", - "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.15" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 90fb67a8eb83d9329b5978bf11d18d4e118f59dd Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Thu, 6 Jul 2023 16:25:43 +0200 Subject: [PATCH 24/30] Fix FD example Signed-off-by: Tom Freudenberg --- examples/workshop/Sol1_3.ipynb | 57 +++++++++++++++++----------------- 1 file changed, 29 insertions(+), 28 deletions(-) diff --git a/examples/workshop/Sol1_3.ipynb b/examples/workshop/Sol1_3.ipynb index 45ae42e7..aa36812f 100644 --- a/examples/workshop/Sol1_3.ipynb +++ b/examples/workshop/Sol1_3.ipynb @@ -181,31 +181,32 @@ "name": "stdout", "output_type": "stream", "text": [ - "Loss at iteration 0 / 5000 is 0.001201\n", - "Loss at iteration 250 / 5000 is 0.000000\n", - "Loss at iteration 500 / 5000 is 0.000000\n", - "Loss at iteration 750 / 5000 is 0.000000\n", - "Loss at iteration 1000 / 5000 is 0.000000\n", - "Loss at iteration 1250 / 5000 is 0.000000\n", - "Loss at iteration 1500 / 5000 is 0.000000\n", - "Loss at iteration 1750 / 5000 is 0.000000\n", - "Loss at iteration 2000 / 5000 is 0.000000\n", - "Loss at iteration 2250 / 5000 is 0.000000\n", - "Loss at iteration 2500 / 5000 is 0.000000\n", - "Loss at iteration 2750 / 5000 is 0.000000\n", - "Loss at iteration 3000 / 5000 is 0.000000\n", - "Loss at iteration 3250 / 5000 is 0.000000\n", - "Loss at iteration 3500 / 5000 is 0.000000\n", - "Loss at iteration 3750 / 5000 is 0.000000\n", - "Loss at iteration 4000 / 5000 is 0.000000\n", - "Loss at iteration 4250 / 5000 is 0.000000\n", - "Loss at iteration 4500 / 5000 is 0.000000\n", - "Loss at iteration 4750 / 5000 is 0.000000\n", - "Loss at iteration 4999 / 5000 is 0.000000\n" + "Loss at iteration 0 / 5000 is 0.047392\n", + "Loss at iteration 250 / 5000 is 0.040498\n", + "Loss at iteration 500 / 5000 is 0.046097\n", + "Loss at iteration 750 / 5000 is 0.038139\n", + "Loss at iteration 1000 / 5000 is 0.041668\n", + "Loss at iteration 1250 / 5000 is 0.037546\n", + "Loss at iteration 1500 / 5000 is 0.034123\n", + "Loss at iteration 1750 / 5000 is 0.041590\n", + "Loss at iteration 2000 / 5000 is 0.043686\n", + "Loss at iteration 2250 / 5000 is 0.035638\n", + "Loss at iteration 2500 / 5000 is 0.037666\n", + "Loss at iteration 2750 / 5000 is 0.038578\n", + "Loss at iteration 3000 / 5000 is 0.040926\n", + "Loss at iteration 3250 / 5000 is 0.037612\n", + "Loss at iteration 3500 / 5000 is 0.040941\n", + "Loss at iteration 3750 / 5000 is 0.031644\n", + "Loss at iteration 4000 / 5000 is 0.034563\n", + "Loss at iteration 4250 / 5000 is 0.030806\n", + "Loss at iteration 4500 / 5000 is 0.041380\n", + "Loss at iteration 4750 / 5000 is 0.034762\n", + "Loss at iteration 4999 / 5000 is 0.035544\n" ] } ], "source": [ + "### Move everything to the GPU\n", "model.to(\"cuda\")\n", "t = t.to(\"cuda\")\n", "t_zero = t_zero.to(\"cuda\")\n", @@ -257,7 +258,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABDAAAAFgCAYAAABNIolGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAB3iUlEQVR4nO3dd3hUVdfG4d9KJ5TQQ++9BghVUYpdESwoKogVe+++fnZfe69gQwQFFBXFXoiC9BJ6771DCJCQsr8/ZnhFBAkhyZny3NeViynnzDwro3sma/bZx5xziIiIiIiIiIgEsgivA4iIiIiIiIiIHI0aGCIiIiIiIiIS8NTAEBEREREREZGApwaGiIiIiIiIiAQ8NTBEREREREREJOCpgSEiIiIiIiIiAU8NDAkpZvaomQ31OsfxMrNaZubMLMrrLCIS3Mws0cz+MLPdZvai13mKmpmtNLNT8rlvDTNLN7PIgs4lIqHDzAab2ZMF/JhXmNn4gnzM43HoeHjoe4v5fGhmO8xsitd5JXSpgSHHxf/BcLOZFT/otmvMLMXDWIdlZl38TYG3Drl9vJldkcfHcGZWr1ACiogcgX+s3ef/8LjR/2G5RB53HwBsBUo55+4qxJiFxsyqmdkoM9tqZrvMbG5ex+1jfJ6/NTucc6udcyWcczkF/VwiEnzMLMX/B3qs11kOdrzNDv/+Of73mHQzW+FvRjQ4sM1hxsND31tOBE4Fqjnn2h1PPSL/Rg0MKQiRwG2F/SQFNBthD9DPzGoVwGMVCs26EJEj6OGcKwEkAa2AB/K4X01gvnPOHesTBtB49DGwBl8t5YB+wCZPE4lIWPF/duwMOOBcb9MUion+95gE4BRgHzDdzJodYftD31tqAiudc3uO9YkD6L1GgoAaGFIQngfuNrPSh7vTzBqZ2c9mtt3MFpnZRQfdl2Jm1xx0/W8dZP+Mh5vMbAmwxH/bq2a2xszSzGy6mXU+hqw7gcHAI0fawMyuMrMF/g77j2ZW03/7H/5NZvm70xeb2e9mdoH//hP8ec/2X+9uZqn+yxFm9pCZrfLPWBliZgn++w4cLnK1ma0GfjtMpgv83wwe6U1ERMKEc24j8CO+RgYAZtbBzCaY2U4zm2VmXfy3Dwb6A/f6x61T/OPR/Wa2zMy2mdlIMyvr3/6w49GRxkX/fc7MrjezJf7nf9PM7KD7r/Xvu9vM5ptZa//tVfyzKrb4v+279V/KbgsMds7tcc5lO+dmOue+P+g5zjWzef7nTzGzxod7EDtkmrf5Zuat9V/+GKgBfOP/Xd1rhxzO58/8tf/9bKmZXXvQYz3q/10O8dc6z8yS/6UmEQkulwOT8H2O7H+Y+8v7P+/u9n8+PPD50czsZf/nvzQzm3Pg85yZJfjHjC3+z4gPmdk//j47dCzy35ZivlnPjYF3gI7+sWun//5YM3vBzFab2SYze8fMih2tSOdcjnNumXPuRuB34NFDMxzmveU64L2DMjzm3+ccM0v1j80TzKzFQflXmtl9ZjYb2ON/3MO+lx1U7xNm9qf/d/yTmZU/6P4TD9p3jfln6eX39yCBSw0MKQjTgBTg7kPvMN+hJT8DnwAVgT7AW2bW5BgevxfQHjiwz1R8H9zL+h/3MzOLO4bHewq4wMwaHiZvT+BB4HygAjAO+BTAOXeSf7OW/il0I/AN7F38t58MLAdOOuj67/7LV/h/ugJ1gBLAG4c8/clAY+D0QzJdCTwLnOKcm3sMdYpICDKzasCZwFL/9arAt8CT+MbFu4FRZlbBOXcFMAx4zj9u/QLcgm9cPRmoAuwA3jzkaf43Hv3buHiQc/A1GVoAF+Efx8ysN74Pv5cDpfB9a7nN/wH9G2AWUBXoDtxuZqdzeJOAN82sj5nVOOT30cCf53Z/vu/wNSFijvBYh+Wc6wesxj/TxTn33GE2Gw6sxfd7uxD4r5l1O+j+c/3blAa+5p/jvIgEr8vxjafD8I2NiYfcfxnwBFAeSPVvB3Aavs+GDfDNbrgI2Oa/73X/bXXwjbuXA1ceSyjn3ALgevwzKJxzpf13PeN/ziSgHr6x9uFjeWzgC3yzTg59ziv4+3vLwEMyPGJmrYAPgOvwzZwbCHxtfz/85hLgbHxjZiJHeC87aPtL8f1+KgIx/m3wN4u+x/f7rOCvObUAfw8SQNTAkILyMHDLIYMM+D7UrnTOfXjgWzNgFND7GB77aefcdufcPgDn3FDn3Db/470IxAL/aEYcif/by3eAxw9z9/X+51vgnMsG/gsk2UHfNh7id3xvOOB7c3r6oOsHNzAuA15yzi13zqXjm/rdx/4+Ze5R/7eL+w667XbgHqCLc25pXmsUkZD0lZntxncoxWb+mknWF/jOOfedcy7XOfczvsbyWUd4nOuB/zjn1jrnMvE1GC78l/EoL+PiM865nc651cBY/podcg2+D7hTnc9S59wqfM2OCs65x51z+51zy4F38TW5D6c3vsbJ/wEr/N/otfXfdzHwrXPuZ+dcFvACUAzodORf5bEzs+rACcB9zrkM51wqvm8cLz9os/H+1yEH32EvLQsyg4h4w8xOxHeIxEjn3HRgGb4/pg/2rXPuD/+4+h98sxGqA1lASaARYP6xdIP5FsPsAzzgnNvtnFsJvIjvELnjzWv41qi4w/8Zeje+sftIY+yRrMfXTMiPAcBA59xk/6yOj4BMoMNB27zmnFvjf6/Jy3vZh865xf7tR/LXe82lwC/OuU+dc1n+vxNSC/D3IAFEDQwpEP6ZAWOA+w+5qybQ3j+da6d/WttlQKVjePg1B18xs7vNNx15l//xEvB1u4/Fs/i654d+uKwJvHpQ1u2A4evWHs5EoIG/C58EDAGq+6e0tQMOHHZSBVh10H6rgCh83eYD/lan3z3Am865tXmsS0RCVy/nXEl8s74a8de4VxPofcg4eyJQ+QiPUxP48qBtFwA5HHk8ysu4uPGgy3vxzTIDqI7vg/7hMlQ5JPODh2T4H+fcDufc/c65pv5tUvE1dIxDxlfnXK4//5HG7fyqAhz4AHzAKv799xBnOrZbJBT0B35yzm31X/+Efx5G8r9x0/9l1XaginPuN3yzsd4ENpvZIDMrhW8Mj+afnw8LYuyqAMTjW8PiwBj7g//2Y1EVXx35URO465Bxvjq+sfSAQ99rjvZedqzvNQX1e5AAojdVKUiPADPwdY8PWAP87pw79Qj77ME3sBxwuMbG/xaeM996F/fim248zzmXa2Y78H2YzjPn3DYzewXfVL+DrQGecs4N++deh32cvWY2Hd8ipnOdc/vNbAJwJ7DsoDe69fgG5gNqANn4FqGrduDhDvMUpwE/mNlG59yovGQSkdDmnPvdf/zxC/gOBVkDfOycu/bf9jvIGuAq59yfh95hfy1w7A7ZPs/j4mGeq+4Rbl/hnKt/rA/onNtqZi/g++OhLL7xtfmB+/1NjerAusPsfrT3nH9b6HQ9UNbMSh7UxKhxhOcRkRDhXy/hIiDSzA78AR0LlDazls65Wf7bqh+0Twn+Gp9wzr0GvGZmFfHNHLgH3+y3LPyLYfp3PdKYcmBhzHggzX/54PHr0LFrK75FOJs6545njDoP3+y3/Djw3vHUv2xz6HvNsbyXHfpchzvzSUH9HiSAaAaGFBj/IQ4jgIMXYhuDb4ZCPzOL9v+0tb8WWEsFzjezePOdnvTqozxNSXx/+G8BoszsYXzHVefHS/imGB+82Ns7wANm1hT+t7jSwYe7bMJ3nOLBfgdu5q/DRVIOuQ6+47PvMLPa/je1/wIj/NOx/8084Ax8x36H4orXIpI/rwCn+meRDQV6mNnpZhZpZnHmW5yy2hH2fQd4yv5aYK6Cf52LIznauPhv3sO3yHMb86nnf94pwG7zLeBWzJ+72UGHhfyNmT3rvz/KzEoCNwBLnXPb8P0xcLb5Fk6OBu7CN015wmEeKhU4y8zKmlklfIfpHexwYzwAzrk1/sd82v87boHvPWtoHn8XIhKceuGbpdYE32zbJHyfHcfx90PIzjLfQpIx+L4gm+ScW+P/3NvePz7tATKAXP+hZiPxjccl/WPjnRxmTHHObcHX2OjrHy+v4u/N4U1ANf9zH5iJ9i7wsr9pgplVtSOvM/Q//sevbWav45vx91hefkmH8S5wvb92M7PiZna2fww/nGN9LzvYMOAUM7vI/z5RzsySjuf3IIFLDQwpaI8DxQ9c8X9LdRq+Y83W45v69Sy+zjXAy8B+fAPvR/y14NGR/Ihv6tdifNPsMjj8oRdH5ZxLA57joGP7nHNf+vMNN7M0YC6+xfIOeBT4yD8N7cDZVH7H11j54wjXwbeI0cf+21b4c9+Sx5yz8K0l8q6ZnXm07UUk9Pk/zA4BHvb/YX1goc0t+MbEezjye/yr+BaY/Ml8a2pMwrdQ8pGe62jj4r/l/AzfwsmfALuBr4Cy/g/u5+D7Q2AFvm/J3sN3SODhxANf4juT1HJ831ie63+ORfiOnX7d/zg98C3Euf8wj/MxvoVDVwI/4Wu6H+xp4CH/GP+PhanxLThXC9/72ZfAI863MKqIhK7++NZeWO2c23jgB99hIZcddJjYJ/hmI28H2uAbl8D3Rdu7+BZMXoVvAc/n/ffdgq+psRwY73+MD46Q41p8Y/s2oCl/b9L+hu9Lr41mdmD27334Fnue5B+7f+Hf14zraGbp+GZ4pPhzt3XOzfmXfY7IOTfNn/kNfLUvxbeg/ZG2P9b3soP3XY1vrYy78P3+U/lrDaJj/T1IgDN37KeFFxEREREREREpUpqBISIiIiIiIiIBTw0MEREREREREQl4amCIiIiIiIiISMBTA0NEREREREREAl7U0TcpOOXLl3e1atXK17579uyhePHiR98wgIVCDRAadaiGwBEKdRxPDdOnT9/qnKtQwJGOKtzHYwiNOlRD4AiFOsK9Bq/GY9CYrBoCRyjUoRoCR6GMyc65Ivtp06aNy6+xY8fme99AEQo1OBcadaiGwBEKdRxPDcA0V4TjsNN4/D+hUIdqCByhUEe41+DVeOw0JquGABIKdaiGwFEYY7IOIRERERERERGRgKcGhoiIiIiIiIgEPDUwRERERERERCTgqYEhIiIiIiIiIgFPDQwRERERERERCXhqYIiIiIiIiIhIwFMDQ0REREREREQCnhoYIiIiIiIiIhLwovKykZmtBHYDOUC2cy7ZzMoCI4BawErgIufcjsKJKSIiB2hMFhEREZFwdCwzMLo655Kcc8n+6/cDvzrn6gO/+q+LiEjR0JgsIiIiImElTzMwjqAn0MV/+SMgBbjvOPMc1oZd+9iRkcumtAzMwDD/vxBh9r/bMIgwMDMMMPPdj/+yYf+43/z3i4gEuSIZk3ftzWJHRi7b0jOJiowgOtKIjowgKsI0noqIiIgIANv37Cdtvyvwx81rA8MBP5mZAwY65wYBic65Df77NwKJBZ7Or9Mzv+EckPJroTz+oc2Q6MgIYqIiiImMIDba/29UpO+2qAhioyIoHhNFqWJRlIqLplSxaErFRVGqWDRl4mOoWCqWSqXiKBMfQ0SEPtCLSIHzbEx+7seFDJu8D1J++dvtZlAixjcOlozzjY0l46IoVyKGxFJxVCwVR2LJWBJLxVE5IY4KJWPV8BAREREJIc45Jq/YzieTV/PD3I10rxHJuQX8HHltYJzonFtnZhWBn81s4SFBnf+D9D+Y2QBgAEBiYiIpKSnHHPKKJjHsy8wkNiYWh++Tu/M/24HLB578wGWH74L7222HbHPw7QfdluMcWbmOrNwcsnNzyMp1ZOdAVhbsy3Fk50JmjmNvNuzJcmTmHD53pEHpWKNsnFExPoKy0VlM3fgLlYpHkBhvxEQG54f39PT0fL2OgUQ1BI5QqMODGvI1JhfEeFyTHPrUdUTFxJLjICfXke0gKxcysh17s7LYm72ftDTHxm0wfb9jV6bj0DAxkZAYH0HFeCMx3jcmVisZQbUSEcRGFc3YqP/2AkMo1AChUYdqEBGR/Ni+Zz9fzFjLJ1NWs3zLHkrGRXFp+xrUj9hU4M+VpwaGc26d/9/NZvYl0A7YZGaVnXMbzKwysPkI+w4CBgEkJye7Ll26HHPILkBKSgr52bcoZOXksjsjm7R9WWzbs5/NaRlsTMtgU1omm9IyWL9zH8u27eXPtGxYlQn4DnWpV7EEzaok0LRqAs2qlKJZ1QSKxx7PUT1FI5Bfi7xSDYEjFOoo6hryOyZ7NR7n5Dq2pWf+b0xct3Mfq7btZdW2Pazctoc5q/exPycX8M3kqFWuOI0qlaRRpVK0qJZAqxqlKR0fc8xZj0b/7QWGUKgBQqMO1SAiInnlnGPKiu18MmU138/ZyP6cXNrULMMLvetxdvPKFIuJJCVlS4E/71H/Wjaz4kCEc263//JpwOPA10B/4Bn/v6MLPF2QiI6MoGzxGMoWj6FW+eJH3O6HX8ZSvUlrVmzdw+KNu5m3Po0/l23li5nrAIiMMJpVKUX7OuVoV6ssbWuVJSE+uqjKEJEgEIxjcmSEUdF/GElzEv5xf06uY92OfSzcmMaCDbtZsCGNBRvS+GHexv/NtqtTvjitapShdc3StKlZhgYVS+oQPREREZEilp6ZzZcz1jJk4iqWbE7/32yLPu2q06hSqUJ//rx83Z8IfOk/VjkK+MQ594OZTQVGmtnVwCrgosKLGRriooymVRJoWiUBWvx1++bdGcxbl8b0VTuYsmI7g/9cyaA/lmMGLaqVpmvDCnRrVJFmVRL0gV1EQm5MjowwapSLp0a5eE5rWul/t6dnZjN77U5mrt7JzNU7GLtoM6NmrAWgbPEYOtUtx4n1ynNCvfJULxvvVXwRERGRkLdsSzofT1zF59PXkp6ZTYtqCTx3YQt6tKhCsZjIIstx1AaGc2450PIwt28DuhdGqHBTsWQcFRvF0bVRRQAysnJIXbOTScu38fviLbz66xJe+WUJ5UvE0rVhBc5sXokT61UgJupYzoIrIqEgnMbkErFRdKpbnk51ywO+qYqrtu1l6srtTFi2jT+XbmXMbN+6pTXKxtO5fnlOaZJIxzrliIsuujdSERERkVCUk+v4beFmhkxcybglW4mJjODsFpXp36kWSdVLe5Ip8BdcCENx0ZF0qFOODnXKcfspDdiWnskfS7bw28It/DhvI59NX0upuChOb1qJs1tU5oR65YmOVDNDREKbmVGrfHFqlS9O7+TqOOdYujmdP5duZfzSrXw5cx3DJq8mPiaSk+pX4JQmiXRrVJGyxQt+/QwRERGRULVjz35GTFvDxxNXsW7nPiqViuPu0xpwcdsaVCgZ62k2NTCCQLkSsZzXqhrntarG/uxcxi/dwpjZG/hhrq+ZUSY+mp5JVemdXM13eIqISBgwM+onlqR+YkmuOKE2GVk5TFy+jV/mb+KXBZv4Yd5GIgw61CnHuS2rcEazSoWyGKiIiIhIKFi+JZ33x69g1Iy1ZGTl0qFOWR46uzGnNkkkKkC+MFcDI8jEREXQrVEi3RolkpGVwx+LtzB61no+mbyawRNW0rRKKS5Krk7PpCr6oC4iYSUuOpKuDSvStWFFnuzVjLnr0vhp/kbGzN7A/V/M4f9Gz+Wk+hU4N6kKpzRO9DquiIQwMysNvAc0AxxwlXNuoqehREQOwznHtFU7GPTHcn5ZsInoiAjOa1WVq06sTcNKJb2O9w9qYASxuOhITmtaidOaVmLn3v18PWs9I6et4ZGv5/HUdws4p0VlruxUm+bVNCtDRMKLmdG8WgLNqyVw56kNmLsuja9nreObWRv4deFmikVH0rqCEV9zO21rlcG/KKqISEF5FfjBOXehmcUAWmlYRAJKdk4uP8zbyLvjVjBrzU5Kx0dzc9d69OtYk4ol47yOd0RqYISI0vExXN6xFpd3rMW89bsYPmUNX8xYyxcz1tGmZhn6d6rFmc0qaa0MEQk7BzczHjizMdNW7eDLmWv5cvoaLho4kTrli3NR2+qc37pqQL9hi0hwMLME4CTgCgDn3H5gv5eZREQO2JOZzYipa/jgzxWs3bGPWuXieaJXMy5sXa1IzyaSX2pghKCmVRJ4olcC95zRkM+nreWjiSu59dOZJJaK5fKOtejboSYJxaK9jikiUuQiIox2tcvSrnZZupTaRlrpeoyYuoZnvl/I8z8u4tTGifTvVIsOdcpqVoaI5FdtYAvwoZm1BKYDtznn9hy8kZkNAAYAJCYmkpKSkq8nS09Pz/e+gUI1BI5QqEM1HN6eLMcvq7L4eVUW6VnQoEwEt7SKpVVFiMhYweQJKwr0+aBw6lADI4SViovmqhNrc0WnWvy+eAsf/LmC539cxDspy7isQ02uPrG256vIioh4JTbK6J1cnd7J1Vm6OZ2R09Ywctoafpi3kUaVSnJFp1r0TKoaFN9GiEhAiQJaA7c45yab2avA/cD/HbyRc24QMAggOTnZdenSJV9PlpKSQn73DRSqIXCEQh2q4e+2pWfy/vgVfDxxFbszs+neqCI3dq1Hm5plCuTx/01hvBZqYISBiAija6OKdG1UkbnrdvH278sY+McyPvhzBRclV+O6k+pSvawOzRSR8FWvYgkePKsxd57agNGp6xg8YRX3fzGHZ35YyMVtq9O/Yy2qlC7mdUwRCQ5rgbXOucn+65/ja2CIiBSZjbsyGPTHcj6ZsorM7FzOalaZG7vWDfqzVqqBEWaaVU3gzUtbs2LrHgb+vowRU9cwfMoaeidX55Zu9fQBXUTCWlx0JBe3rcFFydWZsmI7gyes5N0/lvP+uBX0TKrKDV3qUK9i4K3ILSKBwzm30czWmFlD59wioDsw3+tcIhIe1u3cx5tjl/L5tLXkOEevpKrc0KUu9SqW8DpagVADI0zVLl+cZy5owe2nNODtlKV8MmU1o6av5bIONbixSz0dWiIiYc3MaF+nHO3rlGPtjr28P34Fw6esYdSMtZzWJJEbu9YjqXppr2OKSOC6BRjmPwPJcuBKj/OISIjblJbBm2OXMnzKGgB6J1fj+pNDb6a9GhhhrlJCHI/1bMa1J9Xh9V+XMmTiKoZPWUP/TrW4/uQ6lI6P8TqiiIinqpWJ55EeTbmlW30GT1jJRxNW8tP8P+lYpxw3d6tHp7rltOCniPyNcy4VSPY6h4iEvq3pmbyTsoyPJ60iJ9fRO7k6N3erR9UQnVmvBoYAvg/oz17Yguu71OWVXxYz8I9lfDplNbd2r0+/DjWJidLpV0UkvJUtHsOdpzZgwEl1GD5lNe+OW85l702mfe2y3HVaQ9rVLut1RBEREQkTO/fuZ9Afyxk8YSUZWTmc16oat3WvT41yoTXj4lBqYMjf1C5fnFf7tOL6k+vy3+8W8MSY+QydtIoHz2rMKY0r6ltGEQl7JWKjuKZzHfp2qMnwKat5M2UZFw2cSOf65bnz1Aa0qlH4q3qLiIhIeNq7P5v3x61g0B/LSd+fzTktqnD7KfWpWyE01rg4GjUw5LAaVy7FkKvakbJoC09+O59rh0yjY51yPHROY6+jiYgEhLjoSK44oTYXt63B0EmrePv3ZZz31gS6NarIXac1CPpVvkVERCRwZOfk8vn0tbz082I2787k1CaJ3HVaAxpVKuV1tCKlBoYckZnv9Ksn1i/P8CmreennxZzz+ni6VouiVbssEuKjvY4oIuK5YjGRXHtSHS5tX4PBE1Yy6I/lnPP6eM5vVY27T29A5YTQPAZVRERECp9zjrGLNvPM9wtZvCmd1jVK89ZlrUmuFZ6HrmphAzmq6MgI+nWsRco9XbmiUy3Grsmm24spjJq+Fuec1/FERAJC8dgobupajz/u7cqAznX4ZtZ6ujyfwvM/LmR3RpbX8URERCTIzFqzk0vencRVg6eRleN4p29rRt3QKWybF6AZGHIMEopF80iPptRyGxm9No67PpvFiGlreLJXMxoklvQ6nohIQEgoFs0DZzWmb4eavPDTIt4cu4zhU9Zw+yn16dOuBtGR+u5AREREjmzbvlxu+XQm38xaT7niMTzRs6k+Q/jpNyDHrGapSD6/vhPPXtCcxZt2c9ar43j6+wVkZOV4HU1EJGBULxvPq31a8fXNJ1CvYgn+b/Q8znjlD8Yv2ep1NBEREQlA+/bn8Movi3lg3D5+mreRW7rVI+WeLvTrWEvNCz/9FiRfIiKMi9vW4Le7unBB62oM/H05Z746jqkrt3sdTUQkoLSoVprhAzowqF8bsnIcfd+fzI3DprNu5z6vo4mIiEgAcM7x7ewNnPLS77zyyxKSKkby291duOu0hpSM07qDB1MDQ45L2eIxPHthC4Zd056snFwuGjiRR7+ex57MbK+jiYgEDDPjtKaV+OmOk7jr1Ab8tnAz3V9M4Y3flpCZrdlrIiIi4WrBhjT6DJrETZ/MoFSxaIYP6MCNSXFULa1FwA9HDQwpECfUK8+Pt59E/461+GjiSk5/5Q/+XKpp0iIiB4uLjuSW7vX55c6T6dKgIi/8tJjTX/6DsQs3ex1NREREitCOPft56Ks5nP3aOBZv2s1T5zVjzC0n0qFOOa+jBTQ1MKTAFI+N4tFzmzLyuo5ER0Zw2XuTeeirOezbr28XRUQOVq1MPO/0a8OQq9oREWFcOXgqN30yg827M7yOJiIiIoXIOcdn09bQ/aXf+XTKGi7vWIuUu7tyWfuaREaY1/ECnhoYUuDa1irL97d15poTazN00mrOfn0cc9bu8jqWiEjAOalBBX64zXdYyc/zNnHKi78zfMpqnaJaREQkBC3ZtJuLB03ins9nU6d8cb699UQePbcpCfFa5yKv1MCQQhEXHclD5zThk2vaszczh/Pe+pM3xy4lJ1cfykVEDhYTFcEt3evz/e2daVS5FPd/MYc+gyaxfEu619FERESkAOzbn8NzPyzkzFd9h4s8e0FzRl7XkUaVSnkdLeiogSGFqpN/bYzTm1Xi+R8X0WfQRNZs3+t1LBGRgFO3QgmGX9uBp89vzvwNaZzx6jje+G0JWTm5XkcTERGRfPpt4SZOffl33kpZRq9WVfn1zpO5uG0NInS4SL6ogSGFLiE+mjcuacXLF7dk4YbdnPnqOL6Ztd7rWCIiASciwrikXQ1+vfNkTm2cyAs/Lea8t/5k0cbdXkcTERGRY7B5dwY3DJ3OVYOnERcdyfABHXihd0vKlYj1OlpQUwNDioSZcV6ranx3W2caJJbglk9n8tBXc8jI0gKfIiKHqlgqjjcva807fduwYWcGPV4fz9spy3QYnoiISIA7sEjnKS/+zq8LN3PP6Q357tbOOrtIAVEDQ4pU9bLxjLiuI9edVIehk1Zz/lsTWLF1j9exREQC0hnNKvHTHSfRvXFFnv1hIRe+M0FrY4iIiASotTv20v/Dqdzz+WwaVirJ97d15qau9YiJ0p/dBUW/SSly0ZERPHBWY97vn8z6Xfvo8fp4HVIiInIE5UrE8tZlrXm1TxLLt+zhzFfH8f74FeRqNoaIiEhAyM11DJm4ktNe/oNpK7fzeM+mjBjQkboVSngdLeSogSGe6d44kW9v/euQkv/7ai77s7VYncjRmFmkmc00szH+64PNbIWZpfp/kjyOKAXMzOiZVJWf7ziJE+uV54kx87n0vUls26cxU0RExEvLt6Rz8aCJPDx6Hm1qluGnO07i8o61tEhnIYnyOoCEt6qlizHiuo4898NC3h23gvkb0nj7stZULBXndTSRQHYbsAA4+Nxb9zjnPvcojxSRiqXieK9/Mp9NW8uj38xjzpoc4qtt4Mzmlb2OJiIiElZych3vj1/OCz8tJi4qgucvbMGFbaphpsZFYdIMDPFcdGQE/zm7CW9c2or569M45/XxTF+1w+tYIgHJzKoBZwPveZ1FvGFmXNS2Ot/d2pmK8RHcMGwG94+azd792V5HExERCQurt+3lkkGT+O93Czm5QQV+ufNkeidXV/OiCGgGhgSMc1pUoV7FEgwYMp0+gyby2LnNuLR9Da9jiQSaV4B7gZKH3P6UmT0M/Arc75zLPHRHMxsADABITEwkJSUlXwHS09PzvW8gCYU6bm+aw88bYxgxdQ0p89ZyfctYaiVEeh3rmITC6wChUYdqEBH5d845RkxdwxNj5hNhxou9W3J+66pqXBQhNTAkoDSqVIqvbz6B24an8uCXc5izbiePntuU2Kjg+kAuUhjM7Bxgs3Nuupl1OeiuB4CNQAwwCLgPePzQ/Z1zg/z3k5yc7Lp06XLoJnmSkpJCfvcNJKFQR0pKCm+c24VLl23lzhGzeGpKJnef1pBrO9cJmmNvQ+F1gNCoQzWIiBzZ5rQM7v9iDr8t3EynuuV4vndLqpYu5nWssKNDSCTglI6P4YMr2nJT17p8OmUNlwyaxJbd//gyWSQcnQCca2YrgeFANzMb6pzb4HwygQ+Bdl6GlKLXqW55vr+tM90bJfL09wu56qOp7Niz3+tYIiIiIeHb2Rs47ZU/+HPpVh7p0YShV7dX88IjamBIQIqMMO45vRFvXdaa+RvS6PXmnyzauNvrWCKecs494Jyr5pyrBfQBfnPO9TWzygDmm7/YC5jrXUrxSpniMbzdtzVP9GrGhKXbOPu1ccxYrfWERERE8mvX3ixuGz6Tmz6ZQc2y8Xx7a2euPKF20MxyDEVqYEhAO6t5ZUZe15GsnFwueHsCYxdt9jqSSCAaZmZzgDlAeeBJj/OIR8yMfh1qMuqGTkRGGhe9M5H3x6/AOed1NBERkaAyZcV2znz1D76dvYE7T23AqBs6Ua9iCa9jhb08NzDMLNLMZprZGP/1wWa2wsxS/T9JhZZSwlqLaqUZffMJ1Cgbz9WDpzL4zxVeRxLxnHMuxTl3jv9yN+dcc+dcM+dcX+dcutf5xFvNqyUw5ubOdG1UkSfGzOeGoTNIy8jyOpaIiEjAy87J5aWfF9Nn0ERioiIYdUMnbu1en6hIffcfCI7lVbgNWHDIbfc455L8P6kFF0vk7yonFOOz6zvSvXEij34zn4dHzyU7J9frWCIiASshPppB/drw0NmN+WXBJs55bTxz1+3yOpaIiEjAWrN9LxcPmsRrvy7hvFbVGHNrZ1pWL+11LDlInhoYZlYNOBt4r3DjiBxZ8dgoBvZtw3Un12HIxFVc/dE09mRmex1LRCRgmRnXdK7DiOs6kJWTy/lvT2DktDVexxIREQk4Y2av56zXxrF4425e7ZPEixe1pESsTtoZaPL6irwC3AuUPOT2p8zsYeBX4H7/Cvh/Y2YDgAEAiYmJ+T43dyic1zsUagDv6+hYDPY3jeGj+Vs458WfuaNNHKVij20hHa9rKAihUAOERh2hUIOEtjY1y/LtrZ255dMZ3Pv5bOau28X/ndOEaE2HFRGRMLcnM5vHvpnHyGlraVWjNK/1aUX1svFex5IjOGoDw8zOATY756abWZeD7noA2AjEAIOA+4DHD93fOTfIfz/Jyckuv+fmDoXzeodCDRAYdXQBTlywiZs+mcGLs+GjK9tSq3zxPO8fCDUcr1CoAUKjjlCoQUJf2eIxfHRlO579YSHvjlvBwg27efOy1lQoGet1NBEREU/MXbeLWz+dyYpte7i5az1uO6W+mvsBLi+vzgnAuWa2EhgOdDOzoc65Dc4nE/gQaFeIOUX+oXvjRD69tgO7M7K54O0JpK7Z6XUkEZGAFhUZwX/ObsKrfZKYvW4nPV4fr7FTRETCjnOOoZNWcf7bE9i7P4dPrunA3ac3VPMiCBz1FXLOPeCcq+acqwX0AX5zzvU1s8oAZmZAL2BuYQYVOZxWNcrw+fUdiY+N5JJBk/ht4SavI4mIBLyeSVUZdUMnoiKNiwZO1LoYIiISNtIzs7lteCoPfTWXDnXK8e2tJ9KxbjmvY0keHU+LaZiZzQHmAOWBJwsmksixqVOhBF/ccAJ1Kxbn2iHTGTlVH8RFRI6maZUEvrn5RNrWKsO9n8/m4dFzydLZnUQKhJmtNLM5ZpZqZtO8ziMiPgs3pnHu6+MZM3s995zekMFXtKVcCR1KGUyOaVlV51wKkOK/3K0Q8ojkS4WSsQwf0JEbh83g3lGz2bUvi2tPquN1LBGRgFbGvy7Gcz8uYtAfy1m+ZQ9vXtqahPhor6OJhIKuzrmtXocQEZ+R09bw8Oi5lIyLZtg1HTTrIkjpIB8JGSVio3jv8mTOblGZp75bwIs/LcI553UsEZGAFhUZwYNnNeb5C1swecU2znv7T1Zs3eN1LBERkQKxd382d42cxb2fz6Z1jTJ8d2tnNS+CmE5sKyElJiqC1/q0omRsFK//tpTdGdk8fE4TIiKO7TSrIiLhpndydWqWK851H0+j15t/8k7fNvqAJ5J/DvjJzBww0H9Wvr8xswHAAIDExMR8n447FE7lrRoCRyjUcXAN69NzeTM1g/Xpjp51o+lZbx/zpk/0NmAehMLrAIVThxoYEnIiI4ynz2/um5ExfgVpGVk8d0ELorSqsIjIv2pXuyxf3XQCV380jX7vT+bJXs3o066G17FEgtGJzrl1ZlYR+NnMFjrn/jh4A39TYxBAcnKyy+/puEPhVN6qIXCEQh0Havhuzgae/G0WxaKjGXJ1Ep3rV/A6Wp6FwusAhVOH/qKTkGRm/Ofsxtx1agO+mLGOG4fNIDM7x+tYIiIBr2a54nxxYyc61i3H/V/M4ckx88nJ1eF4IsfCObfO/+9m4EugnbeJRMJHTq7j6e8XcOOwGTSsVJIxt54YVM0L+XdqYEjIMjNu6V6fR3o04af5m7h68DT27s/2OpaISMArFRfNh1e0pX/Hmrw3fgUDhkxjT6bGT5G8MLPiZlbywGXgNGCut6lEwsP2Pft5aXoGA39fzmXtazB8QAcqJxTzOpYUIDUwJORdeUJtnr+wBROWbeWqwVP1IVxEJA+iIiN4rGcznujZlLGLNtNn0CQ2787wOpZIMEgExpvZLGAK8K1z7gePM4mEvLnrdtHj9fEs2pHLcxe04KnzmhMbFel1LClgamBIWOidXJ2XL05iyortXPnhVPZlazq0iEhe9OtYi3cvT2bp5nTOf2sCSzenex1JJKA555Y751r6f5o6557yOpNIqPt8+loueHsCzjkebB/HRW2rex1JCokaGBI2eiZV5dU+rZi+egcvTctgd0aW15FERIJC98aJDB/QgYysHC54ewJTV273OpKIiAj7s3N5ePRc7v5sFm1qluGbW06kToJmXYQyNTAkrPRoWYU3LmnF8l25XP7BFNLUxBARyZOW1UvzxQ0nUK54DJe9N5nv5mzwOpKIiISxzWkZXPLuJIZMXMWAk+ow5Kp2lCsR63UsKWRqYEjYObN5ZW5MimXuul30e28yu/apiSEikhc1ysUz6oZONK+awE2fzOC9ccu9jiQiImFo9tqd9HhjPPPXp/H6Ja148KzGREXqT9twoFdZwlKbxCjevqwN8zek0fe9yezcu9/rSCIiQaFM8RiGXdOe05tU4slvF/D4N/PJ1WlWRUSkiIxOXUfvdyYSFRHBqBs60aNlFa8jSRFSA0PC1ilNEhnYrw2LNu6m3/tTNBNDRCSP4qIjefOy1lx5Qi0++HMFtwyfyf7sXK9jiYhICMvNdTz/40JuG55Ky2qlGX3zCTSpUsrrWFLE1MCQsNatUSLv9GvNwo1pXPHhFNJ1ilURkTyJjDAe6dGUB85sxLezN3D1RzpNtYiIFI70zGyuGzqdN8cuo0/b6gy9pj3ltd5FWFIDQ8Jet0aJvH5Ja2av3cVVH05l7359ABcRyavrTq7Lcxe04M+lW7nsvcns2KND8kREpOCs2b6XC96awG8LN/NojyY8fX5zYqL0Z2y40isvApzRrBKvXJzEtFXbuXbINDKycryOJCISNC5qW523+/rWFeo9cCIbdu3zOpKIiISAScu3ce4b49mwax8fXdmOK06ojZl5HUs8pAaGiF+PllV4/sKWTFi2jRuGTiczW00MEZG8Or1pJT66sh0bd2Vw4dsTWb4l3etIIiISxIZNXkXf9yZTtngMo28+kRPrl/c6kgQANTBEDnJBm2o81as5Yxdt4ZZPZpKVo0XpRETyqmPdcgwf0IGMrBx6vzOROWt3eR1JRESCTE6u49Gv5/GfL+dyYv3yfHnTCdQuX9zrWBIg1MAQOcSl7WvwaI8m/DR/E7ePSCVbTQwRkTxrVjWBz67vSFx0JJe8O4kJy7Z6HUlERILEnsxsrvt4GoMnrOSqE2rzfv+2lIqL9jqWBBA1MEQO44oTavPgWb6V9e//Yg65uc7rSCIiQaNOhRKMuqETlRPiuOLDqYxduNnrSCIiEuA27srgooET+W3hZp7o2ZSHezQhMkLrXcjfqYEhcgQDTqrLbd3r8/n0tfz3uwU4pyaGiEheVUqIY+R1HWmQWIIBH0/j+zkbvI4kIiIBav76NHq9+Scrt+7h/f5t6dexlteRJECpgSHyL24/pT79O9bkvfEreCtlmddxRESCSpniMQy7pgPNqyZw86cz+WrmOq8jiYhIgBm7cDO935mAGXx2fSe6NqrodSQJYGpgiPwLM+ORHk3plVSF539cxNBJq7yOJIKZRZrZTDMb479e28wmm9lSMxthZjFeZxQ5IKFYNB9f3Z52tcpyx8hUhk9Z7XUkEREJEB9NWMnVH02ldoXifHXTCTSpUsrrSBLg1MAQOYqICOP53i3p3qgi/zd6Ll/PWu91JJHbgAUHXX8WeNk5Vw/YAVztSSqRIygeG8WHV7blpPoVuP+LOXz45wqvI4mIiIdych2PfTOPR76eR7dGiYy8riOJpeK8jiVBQA0MkTyIjozgzcta07ZmWe4ckUrKIi1IJ94ws2rA2cB7/usGdAM+92/yEdDLk3Ai/yIuOpJBl7fh9KaJPPbNfN7WYXkiImFp7/5srvt4Oh/+6TvTyMB+bYiPifI6lgQJ/Zcikkdx0ZG8d0UyfQZO4vqh0xl6dXuSa5X1OpaEn1eAe4GS/uvlgJ3OuWz/9bVA1cPtaGYDgAEAiYmJpKSk5CtAenp6vvcNJKFQRzDW0LuqY9f2SJ79YSELlyzjlEr7g66GwwnG1+JQqkFECtvW9EyuHjyVOet28XjPplyuxTrlGKmBIXIMSsVFM+TqdvR+ZyJXDp7KyOs60riyjtWTomFm5wCbnXPTzazLse7vnBsEDAJITk52Xboc80MAkJKSQn73DSShUEew1tC1i+OBL2Yzctpa9ufG8NaAk/FNJgpewfpaHEw1iEhhWrVtD/0/mMLGtAwG9kvm1CaJXkeSIKRDSESOUfkSsXx8dTuKx0TR/4MprN2x1+tIEj5OAM41s5XAcHyHjrwKlDazAw3paoBO9SABLTLCeOb8FvTrUJPvV2TxzPcLdapqEZEQNnvtTs5/awK79mUx7JoOal5IvqmBIZIP1crEM/iqtuzLyuGKD6eyc+9+ryNJGHDOPeCcq+acqwX0AX5zzl0GjAUu9G/WHxjtUUSRPIuIMB7v2ZRuNaIY+MdyNTFERELU2EWb6TNoEsViIvn8hk60qVnG60gSxNTAEMmnRpVKMahfMqu37eXaIdPIyMrxOpKEr/uAO81sKb41Md73OI9InpgZ/RrH0K9DTTUxRERC0Mhpa7jmo2nULl+cL27sRN0KJbyOJEFODQyR49CxbjleurglU1fu4I4RqeTk6oO3FA3nXIpz7hz/5eXOuXbOuXrOud7OuUyv84nklZlvJoaaGCIiocM5x+u/LuHez2fTqW45RlzXkYoldZpUOX5axFPkOJ3Togobd2Xw5LcLePybeTx6btOgX4xORKQoHWhiAAz8YzkA95/ZSGOpiEgQysl1PDx6LsMmr+b8VlV55oIWxETpe3MpGGpgiBSAazrXYeOuDN4bv4LKpYtx/cl1vY4kIhJU1MQQEQl+GVk53PrpTH6av4kbu9TlntMbahyXAqUGhkgBefCsxmxMy+CZ7xdSqVQcvVpV9TqSiEhQURNDRCR47c7I4toh05i8YjuPnduU/p1qeR1JQpAaGCIFJCLCePGilmxNz+Sez2dRvkQsJ9Yv73UsEZGg8o8mhsH9Z6iJISISyLalZ3LFh1NZsCGNVy5OomeSvsiTwqGDkUQKUGxUJAP7JVOnfAluGDqdxZt2ex1JRCToHGhi9O1Qg4G/L+fVX5d4HUlERI5g3c599B44kcWbdvPu5clqXkihUgNDpIAlFIvmgyvbEhcTyZUfTmXLbp0QQkTkWJkZj5/bjN5tqvHKL0t45/dlXkcSEZFDLN2czoVvT2DL7kyGXtOero0qeh1JQpwaGCKFoGrpYrzfP5ltezK5dsg0MrJyvI4kIhJ0IiKMZy5oQY+WVXjm+4UM/nOF15FERMRv9tqdXDRwIlk5jhEDOtK2VlmvI0kYyHMDw8wizWymmY3xX69tZpPNbKmZjTCzmMKLKRJ8WlQrzSsXt2LW2p3cNXIWubnO60giIkEnMsJ46aKWnN40kUe/mc+nU1Z7HUlEJOxNWLaVSwZNIj4mks+v70iTKqW8jiRh4lhmYNwGLDjo+rPAy865esAO4OqCDCYSCs5oVokHzmzEt3M28MJPi7yOIyISlKIjI3jtklZ0aViBB7+cw5cz13odSUQkbP04byNXfDiVqmWK8fn1nahVvrjXkSSM5KmBYWbVgLOB9/zXDegGfO7f5COgVyHkEwl613auwyXtavBWyjJGTlvjdRwRkaAUGxXJO33b0KF2Oe4aOYvv5mzwOpKISNj5auY6bhw2gyaVSzHyuo5USojzOpKEmbyeRvUV4F6gpP96OWCncy7bf30tcNjlZs1sADAAIDExkZSUlHwFTU9Pz/e+gSIUaoDQqKOoa+he2jG7XAQPjJrN1lWLaVIu8rgfMxReBwiNOkKhBpFgEBcdyXv9k+n/wRRu/XQmsVERdG+c6HUsEZGwMHzKah74cg4dapfjvf7JFI/N65+SIgXnqP/Vmdk5wGbn3HQz63KsT+CcGwQMAkhOTnZduhzzQwCQkpJCfvcNFKFQA4RGHV7U0K5TFhe+PYF35mTwxY3tqVexxHE9Xii8DhAadYRCDSLBonhsFB9c2Za+703mhqEzeP+KZDrXr+B1LJF/MLNIYBqwzjl3jtd5RI7H4D9X8Og38zm5QQUG9mtDXPTxfxknkh95OYTkBOBcM1sJDMd36MirQGkzO9AAqQasK5SEIiGiVFw07/dvS0xUBFcNnsr2Pfu9jiQiEpRKxUUz5Kp21KlQnAFDpjN91XavI4kczqHrx4kEpXd+X8aj38zntCaJDLpczQvx1lEbGM65B5xz1ZxztYA+wG/OucuAscCF/s36A6MLLaVIiKheNp53L09mY1oGNwydzv7sXK8jiYgEpdLxMXx8dXsSS8Vy5YdTWbAhzetIIv9z6PpxIsHIOcfLPy/mme8X0qNlFd68rDWxUWpeiLeO58Cl+4DhZvYkMBN4v2AiiYS2VjXK8NwFLbh9RCqPfTOPp85r7nUkEZGgVKFkLB9f3Z7e70zk8g+m8Pn1HalZTqvhS0B4hb+vH/cPWifuL6ohcByowznHZ4uz+G5FFidWjeK8Sjv5c9wfXsfLk1B4LUKhBiicOo6pgeGcSwFS/JeXA+0KNI1ImOjVqioLN+7mnd+X0ahSSfp1rOV1JBGRoFS9bDwfX92O3gMn0vf9yXx+fScSS2lVfPFOXteP0zpxf1ENgSMlJYWTTjqZx76Zx3crVtGvQ00eO7cpERHmdbQ8C4XXIhRqgMKpI0+nURWRgnfP6Q3p3qgij34znwlLt3odR0QkaNVPLMngK9uxPX0//d6fzM69WmNIPPWP9ePMbKi3kUTyJtc5HvxyDh9NXMW1nWvzeM/gal5I6FMDQ8QjkRHGK32SqFuhODd+MoNV2/Z4HUlEJGglVS/Nu5cns3LrXq4cPJU9mdlH30mkEBxh/bi+HscSOarcXMeHc/czfOoabulWjwfPaoyZmhcSWNTAEPFQybho3ru8LQBXfzSN3RlZHicSEQleneqV5/VLWzFrzU6uHzqdzOwcryOJiASF3FzHfaNmM25dNrd1r89dpzVU80ICkhoYIh6rUS6ety5rzcqte7hteCo5uc7rSCIiQev0ppV45oIWjFuylTtGaEwVbznnUpxz53idQ+TfHGhefDZ9LT3rRnPHqQ28jiRyRGpgiASATnXL88i5Tflt4Wae+3Gh13FERILaRcnVeejsxnw3ZyP/+XIOzqmJISJyOAc3L27rXp/z6sd4HUnkX6mBIRIg+nWoSd8ONRj4+3K+mLHW6zgiIkHtms51uLlrPYZPXcOLPy32Oo6ISMA5tHmhmRcSDI7pNKoiUrge6dGUZZv3cP8Xc6hfsSTNqyV4HUlEJGjddVoDtu3J5I2xS6lYKpbLdcpqERFAzQsJXpqBIRJAoiMjePOy1lQoEcv1Q6ezLT3T60giIkHLzHiiZzNOaZzII1/P47s5G7yOJCLiOTUvJJipgSESYMoWj+Gdvm3Ykp7JLZ/OJDsn1+tIIiJBKyoygtcvaUWr6qW5fUQqk5dv8zqSiIhncnMd93+h5oUELzUwRAJQ82oJPH1ecyYs28azP2hRTxGR41EsJpL3+7elepliXDNkGgs3pnkdSUSkyDnnePjruYyctpZbu9VT80KCkhoYIgHqgjbV6N+xJu+OW8Ho1HVexxERCWplisfw0VXtiI+J5IoPprJu5z6vI4mIFBnnHP/9bgFDJ63mupPqqHkhQUsNDJEA9tA5TWhXqyz3jZrN/PX6xlBE5HhUKxPPR1e1Y8/+bPp/MIWde/d7HUlEpEi8/MsS3h23gss71uT+MxthZl5HEskXNTBEAlh0ZARvXNaKhGLRXDd0mj5shzkzizOzKWY2y8zmmdlj/tsHm9kKM0v1/yR5HFUkYDWqVIp3L09m9ba9XPPRNDKycryOJCJSqN5OWcZrvy6hd5tqPNqjqZoXEtTUwBAJcBVLxvF23zZs3JXBLZ/OJCfXeR1JvJMJdHPOtQSSgDPMrIP/vnucc0n+n1SvAooEgw51yvFKnySmr96hxZJFJKQN/nMFz/6wkB4tq/DMBS2IiFDzQoKbGhgiQaB1jTI83rMZ45Zs5cWfFnkdRzzifNL9V6P9P+poieTDWc0r82iPpvw8fxMPfz0P5/S/koiElhFTV/PoN/M5tUkiL13Ukkg1LyQEqIEhEiQuaVeDS9pV562UZXw/Z4PXccQjZhZpZqnAZuBn59xk/11PmdlsM3vZzGK9SygSPPp3qsWNXeryyeTVDPxjuddxREQKzOjUddz/xRxOalCBNy5tRXSk/uyT0BDldQARybtHz23Kgg27ufuzWTzULsbrOOIB51wOkGRmpYEvzawZ8ACwEYgBBgH3AY8fuq+ZDQAGACQmJpKSkpKvDOnp6fneN5CEQh2q4fglxzo6VI7kme8Xsmv9CtpXzt9HI6/rKAiqQSQ0/DhvI3eOnEX72mUZ2LcNsVGRXkcSKTBqYIgEkdioSN66rDXnvD6eN1Iz6HlaNvEx+t84HDnndprZWOAM59wL/pszzexD4O4j7DMIX4OD5ORk16VLl3w9d0pKCvndN5CEQh2qoWCc0DmHfu9N4f15O+nWsTVta5U95scIhDqOl2oQCX4Tlm3llk9m0rxqAu/1b0uxGDUvJLRoLpFIkKlSuhivXJzE+nTHQ1/O1XHbYcTMKvhnXmBmxYBTgYVmVtl/mwG9gLleZRQJRrFRkQzs14ZqpYtx7ZBpLN+SfvSdREQCzOy1O7n2o2nUKh/P4CvbUiJWX3JJ6FEDQyQIndSgAj3rRfPFzHV8OmWN13Gk6FQGxprZbGAqvjUwxgDDzGwOMAcoDzzpYUaRoFSmeAyDr2xHpBlXDp7KtvRMryOJiOTZsi3pXPHhVErHxzDkqvaUjtehxhKa1MAQCVLn1o3mpAYVePTrecxZu8vrOFIEnHOznXOtnHMtnHPNnHOP+2/v5pxr7r+t70FnKhGRY1CjXDzv9k9m464MrhkyjYysHK8jiYgc1fqd++j33mQMGHpNeyolxHkdSaTQqIEhEqQizHjl4iTKl4jhhmHT2bU3y+tIIiJBr3WNMrzaJ4nUNTu5Y0Qqubk6TE9EAtf2Pfvp9/5kdmdk89FV7ahdvrjXkUQKlRoYIkGsbPEY3rysNZvSMrhzpD5oi4gUhDOaVeY/ZzXm+7kbefr7BV7HERE5rPTMbK78cAprduzj3f7JNKua4HUkkUKnBoZIkGtVowwPnd2EXxdu5p0/lnkdR0QkJFx9Ym36d6zJu+NWMGTiSq/jiIj8TWZ2Dtd/PJ2569N489LWdKhTzutIIkVCDQyREHB5x5r0aFmFF35cxIRlW72OIyIS9MyMh3s05ZTGFXn063n8Mn+T15FERADIyXXcOWIW45du5dkLWnBqk0SvI4kUGTUwREKAmfH0+c2pXb44t346k01pGV5HEhEJepERxmuXtKJplQRu+XQmc9dpwWQR8ZZzjifGzOfbORv4z1mNubBNNa8jiRQpNTBEQkSJ2Cje7tuGPZk53PLJTLJzcr2OJCIS9OJjoni/fzKl46O5dsg0NqtBLCIeenfccgZPWMnVJ9bm2pPqeB1HpMipgSESQhokluSZC5ozZeV2Xv5lsddxRERCQsVScbzXP5ld+7K4dsg09u3X6VVFpOiNTl3Hf79byNktfAsNi4QjNTBEQkzPpKr0aVudt1KW8cfiLV7HEREJCU2rJPDKxUnMXreLuz+bpbM+iUiRmrBsK3d/Not2tcvyYu+WRESY15FEPKEGhkgIeqRHUxpULMmdI1M13VlEpICc1rQS95/RiG/nbOAVzXITkSKycGMa1w2ZTu3yxXm3XzJx0ZFeRxLxjBoYIiGoWEwkb1zaij2ZOdw2PJUcfVMoIlIgBpxUh4uSq/Hab0v5auY6r+OISIjbsGsfV3wwlfjYSAZf2Y6E+GivI4l4Sg0MkRBVP7Ekj/dsysTl23jjt6VexxERCQlmxpO9mtO+dlnuHTWb6at2eB1JRELUrn1ZXPHBVPZkZjP4ynZUKV3M60ginlMDQySEXdimGue3qsqrvy5m4rJtXscREQkJMVERvNO3DZUT4rju42ms2b7X60giEmIys3O47uNpLN+azsB+bWhcuZTXkUQCghoYIiHMzHiiVzNqlSvObcNnsi090+tIIiIhoUzxGN7v35bM7Fyu+Wga+7J1qJ6IFAznHPd+PptJy7fzQu+WdKpX3utIIgFDDQyREFc8Noo3Lm3Nzn1Z3DlSK+eLiBSUehVL8PZlbVi6JZ23Z2VqvSERKRAv/7KE0anrufeMhvRMqup1HJGAogaGSBhoUqUUD5/ThN8Xb2HQuOVexxERCRkn1i/PY+c2ZfaWHJ76doHXcUQkyH05cy2v/bqEi5KrccPJdb2OIxJw1MAQCROXta/B2c0r8/yPi5i+arvXcUREQkbfDjU5tWYUH/y5gk8mr/Y6jogEqSkrtnPf53PoWKccT/Zqjpl5HUkk4By1gWFmcWY2xcxmmdk8M3vMf/tgM1thZqn+n6RCTysi+WZmPH1Bc6qUjuOWT2ayc+9+ryOJiISMPg1jOLlBBR4ePZcpK9QkDmdH+uws8m9Wbt3DdR9Po1rZYrzTtw0xUfqeWeRw8vJ/RibQzTnXEkgCzjCzDv777nHOJfl/Ugspo4gUkFJx0bx5aWu2pGdy36jZOKfjtUVECkJkhPHaJa2oUTaeG4ZOZ+0OnZkkjP3bZ2eRf9i5dz9XDZ4KwIdXtCUhPtrjRCKB66gNDOeT7r8a7f/RXz0iQapFtdLcc3pDfpy3iU+nrPE6johIyEgoFs27/ZPZn53LgCHT2bs/2+tI4gF9dpZjsT87l+uHTmftjn0MujyZmuWKex1JJKBF5WUjM4sEpgP1gDedc5PN7AbgKTN7GPgVuN85949zNJrZAGAAQGJiIikpKfkKmp6enu99A0Uo1AChUUe411DPOZqWi+DR0XNgy1KqlPBummK4vxYiElrqVijBa5e04qqPpnLPZ7N549JWOo49DB3us/NhttFnZL9wrcE5x/tz9zNpXTYDWsSyZ+VsUlYWSrw8C9fXItCEQg1QOHXkqYHhnMsBksysNPClmTUDHgA2AjHAIOA+4PHD7DvIfz/JycmuS5cu+QqakpJCfvcNFKFQA4RGHaoBmrXJ4IxXx/Hxsmi+vLETcdGRBRfuGOi1EJFQ07VRRe47oxHPfL+QxmNLcnO3+l5HkiJ2uM/Ozrm5h2yjz8h+4VrDm2OXMn7dIm7rXp87Tm1QOMGOUbi+FoEmFGqAwqnjmL52dc7tBMYCZzjnNvinyGUCHwLtCjSZiBSqiqXieP7CFizYkMZzPyzyOo6ISEi57qQ69Eqqwgs/Lebn+Zu8jiMeOfizs8dRJMCMmb2e539cRM+kKtx+ipqcInmVl7OQVPB3jzGzYsCpwEIzq+y/zYBewNwjPYaIBKbujRO5olMtPvhzBWMXbfY6johIyDAznrmgBS2qJXD78Jks3rTb60hSRI702dnTUBJQUtfs5K6Rs0iuWYZnL2ihw8xEjkFeZmBUBsaa2WxgKvCzc24MMMzM5gBzgPLAk4UXU0QKy/1nNqJhYknu+WwWW3b/YxkbERHJp7joSAb1SyY+Noprh0zT6avDx5E+O4uwcVcGA4ZMo2KpWAb2a+PZIbwiwSovZyGZ7Zxr5Zxr4Zxr5px73H97N+dcc/9tfQ9abVlEgkhcdCSvXdKK3RnZ3P3ZLHJztVC6iEhBqZQQx8B+bdiwM4ObPplBdk6u15GkkB3ps7NIRlYOAz6exp7MbN67vC3lSsR6HUkk6Hh36gERCRgNK5XkobMb8/viLXw4YaXXcUREQkrrGmV46rxm/Ll0G09+u8DrOCLiAecc942azZx1u3j54iQaVirpdSSRoKQGhogA0LdDTU5pnMiz3y9k3vpdXscREQkpvZOrc/WJtRk8YSUjp67xOo6IFLG3f1/G6NT13H1aQ05rWsnrOCJBSw0MEQF8C849d2ELSsdHc+unM9m7P9vrSCIiIeWBMxvRuX55/vPVHKav2uF1HBEpIr/M38TzPy6iR8sq3NilrtdxRIKaGhgi8j9li8fw8sVJLN+6hyfGzPc6johISImKjOCNS1pTpXQxbhg6nc1pGV5HEpFCtnjTbm4bPpNmVRJ4TmccETluamCIyN+cUK88151Ul0+nrOHn+Zu8jiOHMLM4M5tiZrPMbJ6ZPea/vbaZTTazpWY2wsxivM4qIv+UEB/NwH5t2J2RzY3DZrA/W4t6ioSqHXv2c81H04iPjeLdy5MpFqMzjogcLzUwROQf7jy1AU0ql+L+UbN1atXAkwl0c861BJKAM8ysA/As8LJzrh6wA7jau4gi8m8aVSrFcxe2YNqqHTz5rWa7iYSirJxcbhw2g41pGQzq14ZKCXFeRxIJCWpgiMg/xERF8EqfJHZnZnPfqNk4p1OrBgrnc+C01dH+Hwd0Az733/4R0Kvo04lIXvVoWYUBJ9VhyMRVfDZNi3qKhJrHv5nPxOXbeOb85rSqUcbrOCIhI8rrACISmBokluT+Mxrx+Jj5fDJlNZe1r+l1JPEzs0hgOlAPeBNYBux0zh1YeXUtUPUw+w0ABgAkJiaSkpKSr+dPT0/P976BJBTqUA2BIz91tI9zjC8XwQNfzCZ93WJqJ3g7vTwUXotQqEGC39BJq/h40iquO6kO57eu5nUckZCiBoaIHNEVnWrx28LNPDlmAZ3qlqd2+eJeRxLAOZcDJJlZaeBLoFEe9xsEDAJITk52Xbp0ydfzp6SkkN99A0ko1KEaAkd+62jVfj89Xh/Pu/MdX9/SkfIlYgs+XB6FwmsRCjVIcJu4bBuPfj2Prg0rcO8ZeXp7FpFjoENIROSIIiKMF3q3JCYqgjtGpJKdo8XmAolzbicwFugIlDazA03pasA6r3KJSN6VLR7DwH5t2LZnPzd/MkPjrEgQW7N9LzcOm06t8sV59ZJWREbojCMiBU0NDBH5V5US4njqvGakrtnJG2OXeh0n7JlZBf/MC8ysGHAqsABfI+NC/2b9gdGeBBSRY9asagJPn9+cScu388z3C72OIyL5kJnjuO7j6WTnOt69PJlScdFeRxIJSWpgiMhRndOiCue1qsrrvy1l5uodXscJd5WBsWY2G5gK/OycGwPcB9xpZkuBcsD7HmYUkWN0futqXNGpFu+NX8HoVE2gEgkmzjk+nJvJgo1pvHZJKx1yK1KItAaGiOTJo+c2ZfLybdw5chbf3noi8TEaPrzgnJsNtDrM7cuBdkWfSEQKyn/Obsz89WncN2o29SuWpEmVUl5HEpE8eH/8CiZtyOGe0xvStWFFr+OIhDTNwBCRPEkoFs2LFyWxctsenvp2gddxRERCTnRkBG9e1prSxWK4bug0du7d73UkETmKP5du5b/fLaBNYiQ3dqnrdRyRkKcGhojkWce65bi2cx2GTV7Nbws3eR1HRCTkVCgZy9t9W7NpVya3fDqTnFzndSQROYI12/dy8yczqFuhBNc0j8VMi3aKFDY1METkmNx1WgMaVSrJvZ/PYVt6ptdxRERCTqsaZXi8Z1PGLdnKSz8v8jqOiBzGvv05/1u0c9DlyRSLUvNCpCiogSEixyQ2KpJX+iSRti+L+7+Yg3P6dlBEpKD1aVeDPm2r8+bYZfy6QDPeRAKJc477v5jtW7SzjxbtFClKamCIyDFrVKkU95zekJ/nb+KLGVotX0SkMDx6blOaVS3FHSNSWb1tr9dxRMTv/fErGJ26nrtObUDXRlq0U6QoqYEhIvly1Ym1aVurDI9+M48Nu/Z5HUdEJOTERUfy9mVtALh+6HQysnI8TiQiE5Zu5envF3JG00rc1LWe13FEwo4aGCKSL5ERxgu9W5Kd47j389k6lEREpBBULxvPK32SmL8hjYdHz/U6jkhYW7N9Lzd9MoM65YvzwkUttWiniAfUwBCRfKtZrjgPnt2YcUu28smU1V7HEREJSd0aJXJLt3qMnLaWEVM11op44dBFO0vERnkdSSQsqYEhIselb/sadK5fnqe+XaBjtEVECsntpzTgxHrl+b/R85i7bpfXcUTCinOOB/yLdr7aJ0mLdop4SA0METkuZsazF7Qg0oy7P59Fbq4OJRERKWiREcarfZIoXzyG64dOZ+fe/V5HEgkb749fwVep67nzlAZ0a5TodRyRsKYGhogctyqli/FwjyZMWbGdDyes9DqOiEhIKlciljcva82mtAzuHKmGsUhROLBo5+lNE7Vop0gAUANDRArEhW2qcUrjijz3w0KWbk73Oo6ISEhqVaMMD5/ThN8WbuatlKVexxEJaWt37OXmT2dSu3xxXrwoiYgILdop4jU1MESkQJgZ/z2/OcViIrnrs1lk5+R6HUlEJCT17VCTXklVePHnxYxbssXrOCIh6cCinVk5uQzq10aLdooECDUwRKTAVCwZxxM9mzFrzU4G/rHc6zgiIiHpQMO4fsUS3DY8lfU793kdSSSkOOf4z5dzmL/Bt2hnnQolvI4kIn5qYIhIgerRsgpnt6jMK78sZsGGNK/jiIiEpPiYKN7u24b92bncOGwG+7M1602koHw8aRVfzFzHbd3ra9FOkQCjBoaIFLgnejYjoVgMd46cpQ/VIiKFpG6FEjx/YQtS1+zkyW/nex1HJCRMX7Wdx7+ZT7dGFbm1W32v44jIIdTAEJECV7Z4DE+f35wFG9J4/bclXscREQlZZzavzLWdazNk4iq+mbXe6zgiQW3z7gxuGDqDqmWK8bIW7RQJSGpgiEihOLVJIhe0rsZbKcuYvXan13FERELWvWc0ok3NMtw/ajbLt+gsUCL5kZWTy83DZpKWkcU7fduQEB/tdSQROQw1MESk0DzcownlS8Rw7+ezdSiJiEghiY6M4PVLWhETFcGNw2aQkZXjdSSRoPPf7xYwZeV2nr2gBY0rl/I6jogcgRoYIlJoEopF89/zmrNw427eGLvU6zgiIiGrSulivHRxEgs37uaxb+Z5HUckqIxOXceHf67kik616JlU1es4IvIv1MAQkULVvXEi57WqyltjlzJv/S6v44iIhKyuDStyY5e6fDplDV/OXOt1nLBlZtXNbKyZzTezeWZ2m9eZ5MgWbkzj/lFzaFurDP85u7HXcUTkKNTAEJFC90iPJpSOj+Gez2aTlaNDSURECsudpzagXe2yPPjFXJZu3u11nHCVDdzlnGsCdABuMrMmHmeSw9i1L4vrPp5Oibgo3ry0NdGR+tNIJNDp/1IRKXSl42N4slcz5m9I452UZV7HEREJWVH+9TDiYyK5cdgM9u7P9jpS2HHObXDOzfBf3g0sAHRcQoDJzXXcOSKVdTv28fZlralYKs7rSCKSB2pgiEiROKNZJc5pUZnXflvCoo36VlBEpLAklorjlT5JLNmczsOjtR6Gl8ysFtAKmOxxFDnEG2OX8uvCzfzfOU1IrlXW6zgikkdRR9vAzOKAP4BY//afO+ceMbPawHCgHDAd6Oec21+YYUUkuD12blMmLNvGPZ/P4osbOhGlqZoiIoWic/0K3NKtPq/9uoT2tcvSO7m615HCjpmVAEYBtzvn0g5z/wBgAEBiYiIpKSn5ep709PR87xsoirqG2VuyeXl6Jh2rRFIjcwUpKSuP+zFD4XWA0KhDNQSOwqjjqA0MIBPo5pxLN7NoYLyZfQ/cCbzsnBtuZu8AVwNvF2g6EQkp5UrE8ti5Tbnl05m8O24FN3Sp63UkEZGQdVv3+kxbuZ3/Gz2XFtVK07BSSa8jhQ3/Z+ZRwDDn3BeH28Y5NwgYBJCcnOy6dOmSr+dKSUkhv/sGiqKsYfW2vdz6+jgaVS7FB9d3olhMZIE8bii8DhAadaiGwFEYdRz160/nk+6/Gu3/cUA34HP/7R8BvQo0mYiEpHNaVOb0pom8/Mtilm5OP/oOIiKSL5ERxit9kigRG82Nw6azJ1PrYRQFMzPgfWCBc+4lr/PIX/btz+G6odMBeKdv6wJrXohI0cnLDAzMLBLfYSL1gDeBZcBO59yBd8K1HGFxIk2P+0so1AChUYdq8NaZFXMZvziX6z8Yx61Nc4K2jgOC+bUQkdBWsWQcr12SRN/3JvOfL+fw8sVJ+P6+lkJ0AtAPmGNmqf7bHnTOfeddJHHO8Z8v57BwYxof9G9LzXLFvY4kIvmQpwaGcy4HSDKz0sCXQKO8PoGmx/0lFGqA0KhDNXjPVVzLHSNmMXFbLE/36OJ1nOMS7K+FiIS2TnXLc/spDXjp58W0r1OOS9rV8DpSSHPOjQfUJQowH09axRcz13HHKQ3o2qii13FEJJ+OaQU959xOYCzQEShtZgcaINWAdQUbTURCWa+kqnRvVJFRi/ezcuser+MEBTOrbmZjzWy+mc0zs9v8tz9qZuvMLNX/c5bXWUUksNzUtR6d65fnka/nMX/9P9aTFAlp01dt5/Fv5tO9UUVu6VbP6zgichyO2sAwswr+mReYWTHgVHznsx4LXOjfrD8wupAyikgIMjOeOq85kRFw76jZ5OY6ryMFg2zgLudcE6ADcJOZNfHf97JzLsn/o2nKIvI3kRHGyxcnUSY+mps+mUG61sOQMLF5dwY3DJ1B1TLFeOniJCIiNDlGJJjlZQZGZWCsmc0GpgI/O+fGAPcBd5rZUnynUn2/8GKKSCiqlBDHpY1imLJiOx9PWuV1nIDnnNvgnJvhv7wbXzP5sOsPiYgcqnyJWF6/pDWrtu3hoS/n4JwaxxLasnNyufmTmaRlZPFO3zYkFIv2OpKIHKejroHhnJsNtDrM7cuBdoURSkTCx4lVo1iyP4HnfljIKU0SqVq6mNeRgoKZ1cI3Nk/Gt2DczWZ2OTAN3yyNHYfZR4sqHyQU6lANgSOY6uhZN5ovU9dTLnsrnav99QddMNVwJKFQgxSc539axJQV23n54pY0rlzK6zgiUgDytIiniEhhMTOe6tWM017+g4e+nMMHV7TVCvlHYWYlgFHA7c65NDN7G3gC3ymunwBeBK46dD8tqvx3oVCHaggcwVRH55McG9+bzCeLdnLJaR2oV7EkEFw1HEko1CAF46d5Gxn4+3Iua1+D81pV8zqOiBSQY1rEU0SkMFQvG8/dpzdk7KItfD1rvddxApqZReNrXgxzzn0B4Jzb5JzLcc7lAu+i2XEi8i8iI4xX+iQRHxPJzZ/MJCMrx+tIIgVq1bY93PXZLFpUS+DhHk2OvoOIBA01MEQkIFzRqRYtq5fmsW/ms33Pfq/jBCTzTU15H1jgnHvpoNsrH7TZecDcos4mIsElsVQcL17UkoUbd/Pkt/O9jiNSYDKycrh+6AwizHjz0tbERkV6HUlECpAaGCISECIjjGcvaE7aviyeGKMP00dwAtAP6HbIKVOfM7M5/sWWuwJ3eJpSRIJCl4YVue6kOgydtJrv52zwOo5IgXhk9DwWbEjj5YtbUr1svNdxRKSAaQ0MEQkYjSqV4sYudXntt6X0TKpCl4YVvY4UUJxz44HDLRCi06aKSL7cdVpDJq3Yzr2jZvNwO52hQYLbyGlrGDFtDTd3rUe3RolexxGRQqAZGCISUG7qVo+6FYrzny/nsicz2+s4IiIhLSYqgjcu8Z1s7u1ZmWTl5HqcSCR/5q3fxf99NZdOdctxx6kNvI4jIoVEDQwRCSixUZE8e0EL1u/ax/M/LvI6johIyKteNp5nL2jB8l25vPCTxl0JPmkZWdw4bAal46N57ZJWREbobGYioUoNDBEJOMm1ytKvQ00+mriSGat3eB1HRCTkndW8Ml2rRzHw9+WkLNrsdRyRPHPOcffIWazbsY83L21N+RKxXkcSkUKkBoaIBKR7Tm9IpVJx3D9qNvuzNaVZRKSwXdIohkaVSnLXyFlsSsvwOo5Inrw7bjk/zd/E/Wc2IrlWWa/jiEghUwNDRAJSybhonuzVjMWb0nk7ZZnXcUREQl5MpPHGpa3Yuz+HO0akkpPrvI4k8q+mrNjOsz8s4sxmlbj6xNpexxGRIqAGhogErO6NE+nRsgpvjF3Ckk27vY4jIhLy6lUsyWM9mzJh2TbeGrvU6zgiR7QtPZNbPp1B9TLFeO7CFphp3QuRcKAGhogEtEd6NKF4bBT3jZqtbwNFRIpA7zbV6JVUhZd/WcyUFdu9jiPyD7m5jrs+m8WOvVm8eVlrSsbpFMAi4UINDBEJaOVLxPJ/ZzdhxuqdDJ20yus4IiIhz8x48rzm1Cgbz23DZ7Jjz36vI4n8zXvjl5OyaAv/d3ZjmlZJ8DqOiBQhNTBEJOCd37oqneuX57kfFrJu5z6v44iIhLwSsVG8cWlrtqXv557PZ+OcZsBJYJixegfP+de96NuhptdxRKSIqYEhIgHPzPjvec3JdfDwV3P1QVpEpAg0q5rAfWc24pcFmxg6ebXXcUTYtTeLWz6ZSaWEOJ65QOteiIQjNTBEJChULxvPHafW59eFm/lh7kav44iIhIUrO9Xi5AYVeHLMfBZt1GLK4h3nHPeO8p3i941LW5NQTOteiIQjNTBEJGhcdUJtGlcuxSNfzyMtI8vrOCIiIS8iwnihd0tKxkVx66czycjK8TqShKkhE1fx47xN3H9mI5Kql/Y6joh4RA0MEQkaUZERPH1+c7akZ/Lij4u8jiMiEhYqlIzlhd4tWbRpN09/t8DrOBKG5q7bxVPfLqB7o4pcfWJtr+OIiIfUwBCRoJJUvTSXd6jJkEmrmLl6h9dxRETCQpeGvj8cP5q4il8XbPI6joSR3RlZ3PzJDMqViOGF3i217oVImFMDQ0SCzt2nN6RiyVge+GIOWTm5XscREQkL957RkCaVS3HP57PZnJbhdRwJA845/vPlXNbs2Mdrl7SiTPEYryOJiMfUwBCRoFMyLprHzm3Kwo27+WD8Cq/jiIiEhdioSF67pBV792dz58hZ5ObqjFBSuEbNWMfXs9Zzxyn1aVurrNdxRCQAqIEhIkHp9KaVOKVxIi//spg12/d6HUdEJCzUq1iCR3o0ZfzSrbw7brnXcSSErdq2h0dGz6Vd7bLc0KWe13FEJECogSEiQcnMeKxnUyLMeHj0XJzTN4EiIkWhT9vqnNmsEs//uIjZa3d6HUdCUFZOLrcNTyUiwnj54iQiI7TuhYj4qIEhIkGrauli3HVaQ8Yu2sK3czZ4HUdEJCyYGU+f35wKJWO5bXgqezKzvY4kIeb135aSumYn/z2vOVVLF/M6jogEEDUwRCSo9e9Yk2ZVS/HYN/PZtS/L6zgiImGhdHwMr1ycxMpte3j063lex5EQMm3ldt74bQnnt65Kj5ZVvI4jIgFGDQwRCWpRkRE8fV4LtqVn8twPC72OIyISNtrXKcfNXevx2fS1fDNrvddxJASkZWRx2/BUqpWJ57Fzm3odR0QCkBoYIhL0mldL4IpOtRk2eTXTV+3wOo6ISNi4rXt9WtcozYNfztGCynLcHv5qLhvTMnj54iRKxkV7HUdEApAaGCISEu48rQGVE+J48Is5ZOXkeh1HRCQsREVG8GqfVuDg9hGpZGv8lXz6auY6vkpdz63d6tOmZhmv44hIgFIDQ0RCQonYKB7v2YxFm3br1H4iIkWoetl4njyvGdNX7eD135Z6HUeC0Ja9ufzfV3NpU7MMN3Wt63UcEQlgamCISMg4tUkipzdN5NVflrB6m6Yyi4gUlZ5JVbmgdTVe/20JU1Zs9zqOBJHsnFwGzc4E4JWLk4iK1J8nInJkGiFEJKQ8dm4zoiMjeGj0XJxzXscREQkbj/VsSo2y8dwxIpW0jPA+K5SZfWBmm81srtdZAt1bKctYsjOXJ3o1o3rZeK/jiEiAUwNDREJKpYQ47jqtAX8s3sJ3czZ6HUdEJGyUiI3i5YuT2JiWwcNfhf3f7YOBM7wOEehmrN7Bq78uoUPlSHq1qup1HBEJAmpgiEjI6dehJk0ql+LxMfPYHebfAoqIFKVWNcpwW/f6fJW6ntGp67yO4xnn3B+AjqX5F+mZ2dw+PJVKpeLo1yTW6zgiEiSivA4gIlLQoiIjeOq8Zpz/9gRe+WUJ/3dOE68jFQgzqw4MARIBBwxyzr1qZmWBEUAtYCVwkXNO55MVEU/c2KUuvy/ewkP+RRmrldFhAYdjZgOAAQCJiYmkpKTk63HS09Pzva+X3puTyZrt2dzfLg6XuTcoazhYsL4OhwqFOlRD4CiMOtTAEJGQ1KpGGS5pV4PBE1ZyQetqNKlSyutIBSEbuMs5N8PMSgLTzexn4ArgV+fcM2Z2P3A/cJ+HOUUkjEVFRvDyRUmc9do47ho5i0+u7UBkhHkdK+A45wYBgwCSk5Ndly5d8vU4KSkp5Hdfr4yZvZ7x62ZyS7d6XHdaw6Cs4VChUAOERh2qIXAURh06hEREQta9pzekdLFoHvpqDrm5wb+gp3Nug3Nuhv/ybmABUBXoCXzk3+wjoJcnAUVE/GqUi+fRc5syecV2Bv2hU1vLX9bv3MeDX8whqXppbu1e3+s4IhJkjtrAMLPqZjbWzOab2Twzu81/+6Nmts7MUv0/ZxV+XBGRvCsdH8MDZzVmxuqdjJy2xus4BcrMagGtgMlAonNug/+ujfgOMRER8dQFratydvPKvPTzIuau2+V1HAkAObmOO0akkpPreOXiJKJ1ylQROUZ5OYTkSFOWAV52zr1QePFERI7PBa2rMnLqGp75YSGnNa1E2eIxXkc6bmZWAhgF3O6cSzP7a2q2c86Z2WGnm4T78daHCoU6VEPgCIU6CqOGMys4JkTBtR/8yaOdihEbWbiHkgTK62BmnwJdgPJmthZ4xDn3vrepvDfwj2VMXrGd5y9sQa3yxb2OIyJB6KgNDP+3ehv8l3eb2YEpyyIiAc/MePK8Zpz16jie+X4Bz13Y0utIx8XMovE1L4Y5577w37zJzCo75zaYWWVg8+H2DefjrQ8nFOpQDYEjFOoorBrK1NnKZe9NZvzuCjzRq1mBP/7BAuV1cM5d4nWGQDN77U5e+mkxZzevzIVtqnkdR0SC1DHN2zpkyjLAzWY228w+MLMyBR1ORKQgNEgsydWdazNy2lqmrQzes9qZb6rF+8AC59xLB931NdDff7k/MLqos4mIHMkJ9cpzbefafDxpFb8t3OR1HPHA3v3Z3DY8lQolY/nvec05eOagiMixyPNZSA4zZflt4Al8p/J7AngRuOow+2nKsl8o1AChUYdqCBxFVUfraEfZOOP2oZN4tFMxogpwRfwifC1OAPoBc8ws1X/bg8AzwEgzuxpYBVxUFGFERPLq7tMbMm7JVu79fDY/3H4S5UvEeh1JitATY+azctsePrmmAwnx0V7HEZEglqcGxuGmLDvnNh10/7vAmMPtqynLfwmFGiA06lANgaNI66i8kes+ns6KqJpce1KdAnvYoqrBOTceOFLnpXuhBxARyafYqEheu6QV57w+nvs+n817/ZP1LXyY+GHuRj6dsoYbutSlY91yXscRkSCXl7OQHHbKsv846wPOA+YWfDwRkYJzWpNEujeqyMu/LGb9zn1exxERCSsNEkvywJmN+HXhZoZNXu11HCkCG3dlcP8Xs2leNYE7TmngdRwRCQF5WQPjwJTlboecMvU5M5tjZrOBrsAdhRlUROR4mRmPntuUXOd4Ysx8r+OIiISd/h1rcVKDCjz57XyWbk73Oo4Uotxcx12fpZKZlcurfZKIidIpU0Xk+B11JHHOjXfOmXOuhXMuyf/znXOun3Ouuf/2c/1nKxERCWjVy8ZzS7f6fD93I2MXHfZkHSIiUkgiIowXLmxBsehIbh8xk/3ZuV5HkkLy3vjl/Ll0G4/0aEKdCiW8jiMiIUKtUBEJO9d2rkPdCsV5ZPQ8MrJyvI4jIhJWKpaK45kLWjB3XRqv/LLY6zhSCGau3sFzPyzijKaVuLhtda/jiEgIUQNDRMJOTFQET/Rsxurte3lr7FKv44iIhJ3Tm1aiT9vqvP37MiYv3+Z1HClAu/ZmcfMnM6mUEMezF7TQYq0iUqDUwBCRsNSpXnl6JVXhnd+Xs3yLjsMWESlq/3dOE2qWjefOkbNIy8jyOo4UAOcc93w+i01pGbx+SSudMlVECpwaGCISth48uzGx0RE8PHoezjmv44iIhJXisVG8fHESG9MyePgrncwuFHz450p+mr+J+89sRKsaZbyOIyIhSA0MEQlbFUvGcfdpDRm/dCvfz93odRwRkbDTqkYZbu1Wn69S1/PtbK0HH8xmrdnJ098v4JTGiVx9Ym2v44hIiFIDQ0TC2mXta9C4cimeHDOfvfuzvY4jIhJ2bupal5bVS/Ofr+awOS3D6ziSD7v2ZXHzpzOoWDKOF3pr3QsRKTxqYIhIWIuKjOCJnk1ZvyuDN37Tgp4iIkUtKjKCly9qSUZWDvd8PluH9AWZnFzHbcNnsnFXBq9d0orS8TFeRxKREKYGhoiEveRaZTm/dVXeHacFPUVEvFCnQgn+c1Zjfl+8haGTV3sdR47BK78sJmXRFh7p0ZQ2NbXuhYgULjUwRESAB85sTFxUJI98rQU9RUS80LdDTU5qUIH/fruAFVv3eB1H8uCHuRt5/belXJxcncva1/A6joiEATUwRESACiVjufO0BoxbspUf52lBTxGRomZmPH9hC2KiIrhjRCrZObleR5J/sXTzbu4amUrL6qV5rGdTrXshIkVCDQwREb9+HWrSqFJJnhizgH37c7yOIyISdhJLxfFkr2akrtnJ2ynLvI4jR7B9z36u+WgaxWIieadva+KiI72OJCJhQg0MERG/qMgIHu/ZjHU79/HmWC3oKSLihR4tq3Buyyq8+usS5qzd5XUcOURGVg4Dhkxj/a4MBvZrQ+WEYl5HEpEwogaGiMhB2tUuy3mtqjLoj+U6BltExCNP9GxG+RKx3DEylYwszYgLFLm5jns+n820VTt46aKWtKlZ1utIIhJm1MAQETnEA2c2IiYqgke1oKeIiCcS4qN5vncLlm5O57kfFnkdR/xe+nkx38xaz71nNOScFlW8jiMiYUgNDBGRQ1QsFcftp9Tn98Vb+Gn+Jq/jiIiEpc71K9C/Y00++HMFE5Zu9TpO2PvwzxW8MdZ3xpEbTq7rdRwRCVNqYIiIHEb/TrVomFiSx7+ZrwU9RUQ8cv+ZjalToTh3fzaLXfuyvI4Ttj6btobHvpnP6U0Teeq8ZjrjiIh4Rg0MEZHDiI6M4PGeTVm3cx9vp2hBTxERLxSLieTli5LYtDuTR7+e53WcsPT9nA3cN2o2neuX57VLWhEVqT8fRMQ7GoFERI6gfZ1y9Eyqwjt/LGelFvQUEfFEy+qluaVbPb6cuY7v5mzwOk5Y+W7OBm75dCatapRhYL82xEbpdKki4i01MERE/sWDZzUmOsJ47Bst6Cki4pWbutajZbUEHvxyDpvTMryOExa+mLGWmz+ZQVL10nx4ZVviY6K8jiQiogaGiMi/SSwVx+2nNGDsoi38smCz13FERMJSdGQEL12cREZWDveOmq2GciEbNnkVd302iw51yjHk6naUiov2OpKICKAGhojIUV1xQi3qVyzBY9/MIyNLC3qKiHihboUSPHBmY1IWbeGTKau9jhOScnMdz/2wkP98OZcuDSrwwRWaeSEigUUNDBGRo4iOjOCxnk1Zu2Mfb6cs8zqOiEjY6tehJp3rl+fJMQu0NlEBy8jK4ZZPZ/JWyjIuaVedQZcnExetNS9EJLCogSEikged6panR8sqvP37MlZv2+t1HBGRsBQRYTx/YUuiI407R6aSnZPrdaSQsGrbHi58ZwLfzd3Ag2c14r/nNSdaZxsRkQCkkUlEJI/+41/Q8/ExOpWfiIhXKiXE8USvZsxYvZOBfyz3Ok7Q+3b2Bs55bTxrtu/j3X7JDDipLmbmdSwRkcNSA0NEJI8qJcRxS/f6/LJgM2MXaUFPERGv9EyqytktKvPKL4uZvz7N6zhBafue/dwxIpWbPplBvcQSfHvriZzSJNHrWCIi/0oNDBGRY3DVCbWpU744j38zn8xsLegpIuKVJ3s2o3R8DHeOTNV4fAxycx1fzVzHKS/9zpjZ67m1e31GXteRamXivY4mInJUamCIiByDmKgIHu7RhBVb9/DB+JVF/vxm9oGZbTazuQfd9qiZrTOzVP/PWUUeTESkiJUpHsOzFzRn4cbdvPrLEq/jBIUJS7fS660/uX1EKtXLxjPmls7ceWoDrXchIkFD50USETlGXRpW5JTGibz+2xLOa1W1qJ9+MPAGMOSQ2192zr1Q1GFERLzUrVEiFydX553fl9G9ceAc/mBmZwCvApHAe865Z7zKkp2Ty0/zN/HeuOXMWL2TKglxvNi7Jb1aVSUyQmtdiEhwUQNDRCQfHj6nCae8/DtPf7+A8yoV3fM65/4ws1pF94wiIoHtoXMaM37pVu7+bBb3Jzmv42BmkcCbwKnAWmCqmX3tnJtfVBmycnJJXbOTb2dv4Ns5G9iyO5MaZeN5tEcT+rSrodOjikjQUgNDRCQfapSL57qT6vD6b0tp0i6OLl4HgpvN7HJgGnCXc27HoRuY2QBgAEBiYiIpKSn5eqL09PR87xtIQqEO1RA4QqGOYK6hb33Hs1P3MGyeIzYqxes47YClzrnlAGY2HOgJFGgDY9/+HJZtSWfR9hzcws1s2JXBiq3pLNy4m+mrdrB3fw4xURF0a1iR81pX5ZTGiZpxISJBTw0MEZF8urFLPb6YsY7hizIZ4JyXp517G3gCcP5/XwSuOnQj59wgYBBAcnKy69KlS76eLCUlhfzuG0hCoQ7VEDhCoY5grqELsDlmHh/+uZJ7LmhF82oJXsapCqw56PpaoH1BP8myLemc8/p435UpUwHfOk11K5TgwjbVaF+7HJ0blKdUXHRBP7WIiGfUwBARyadiMZG8dFFLViyY5WXzAufcpgOXzexdYIxnYUREPHLfGY2I3b2BZlVLeR0lT453Vty+bMetrWJxWRkklChG6VijbJwRYTnAVti+lRmTFhV88EIQzLN/DgiFGiA06lANgaMw6lADQ0TkOLSvU459q71dvd3MKjvnNvivngfM/bftRURCUVx0JB2qRHnaUPZbB1Q/6Ho1/21/UxCz4s4kuGfOHKAaAkco1KEaAkdh1KEGhohIEDGzT/HNli5vZmuBR4AuZpaE7xCSlcB1XuUTERGmAvXNrDa+xkUf4FJvI4mIhAY1MEREgohz7pLD3Px+kQcREZHDcs5lm9nNwI/4TqP6gXNunsexRERCghoYIiIiIiIFyDn3HfCd1zlEREKNtwdui4iIiIiIiIjkwVEbGGZW3czGmtl8M5tnZrf5by9rZj+b2RL/v2UKP66IiIiIiIiIhKO8zMDIBu5yzjUBOgA3mVkT4H7gV+dcfeBX/3URERERERERkQJ31AaGc26Dc26G//JuYAFQFegJfOTf7COgVyFlFBEREREREZEwd0yLeJpZLaAVMBlIdM5t8N+1EUg8wj4DgAEAiYmJpKSk5Ctoenp6vvcNFKFQA4RGHaohcIRCHaFQg4iIiIhIoMtzA8PMSgCjgNudc2lm9r/7nHPOzNzh9nPODQIGASQnJ7suXbrkK2hKSgr53TdQhEINEBp1qIbAEQp1hEINIiIiIiKBLk9nITGzaHzNi2HOuS/8N28ys8r++ysDmwsnooiIiIiIiIiEu7ychcSA94EFzrmXDrrra6C//3J/YHTBxxMRERERERERAXPusEd+/LWB2YnAOGAOkOu/+UF862CMBGoAq4CLnHPbj/JYW/zb5kd5YGs+9w0UoVADhEYdqiFwhEIdx1NDTedchYIMkxcaj4HQqEM1BI5QqCPca/BkPAaNyaiGQBIKdaiGwFHgY/JRGxiBwsymOeeSvc5xPEKhBgiNOlRD4AiFOkKhhmMRKvWGQh2qIXCEQh2qITiFQs2qIXCEQh2qIXAURh15WgNDRERERERERMRLamCIiIiIiIiISMALpgbGIK8DFIBQqAFCow7VEDhCoY5QqOFYhEq9oVCHaggcoVCHaghOoVCzaggcoVCHaggcBV5H0KyBISIiIiIiIiLhK5hmYIiIiIiIiIhImFIDQ0REREREREQCXsA1MMzsDDNbZGZLzez+w9wfa2Yj/PdPNrNaHsT8V3mo4Qoz22Jmqf6fa7zI+W/M7AMz22xmc49wv5nZa/4aZ5tZ66LOeDR5qKGLme066HV4uKgzHo2ZVTezsWY238zmmdlth9kmoF+LPNYQDK9FnJlNMbNZ/joeO8w2AT8+HQuNx4FB43FgCIXxGEJjTNZ4HJzjMQT/mBwK4zFoTA4UoTAegwdjsnMuYH6ASGAZUAeIAWYBTQ7Z5kbgHf/lPsAIr3Pno4YrgDe8znqUOk4CWgNzj3D/WcD3gAEdgMleZ85HDV2AMV7nPEoNlYHW/sslgcWH+e8poF+LPNYQDK+FASX8l6OByUCHQ7YJ6PHpGOvVeBwgPxqPA+MnFMbjY6gjoF8PjcfBNx4fQx0BPSaHwnicxzoCegzwZwz6MTkUxmN/xiIdkwNtBkY7YKlzbrlzbj8wHOh5yDY9gY/8lz8HupuZFWHGo8lLDQHPOfcHsP1fNukJDHE+k4DSZla5aNLlTR5qCHjOuQ3OuRn+y7uBBUDVQzYL6NcijzUEPP/vN91/Ndr/c+gqyIE+Ph0LjccBQuNxYAiF8RhCY0zWeByU4zGEwJgcCuMxaEwu4qhHFArjMRT9mBxoDYyqwJqDrq/lny/i/7ZxzmUDu4ByRZIub/JSA8AF/qlMn5tZ9aKJVqDyWmeg6+if7vS9mTX1Osy/8U+1aoWvq3mwoHkt/qUGCILXwswizSwV2Az87Jw74msRoOPTsdB4HDyCZgw4ioAfAw4IhfEYgntM1ngcdOMxhMeYHFRjwFEE9BhwsFAYk4N5PIaiHZMDrYERLr4BajnnWgA/81c3SorWDKCmc64l8DrwlbdxjszMSgCjgNudc2le58mPo9QQFK+Fcy7HOZcEVAPamVkzjyPJ8dN4HBiCYgyA0BiPIfjHZI3HIUtjcmAI+DHggFAYk4N9PIaiHZMDrYGxDji401rNf9thtzGzKCAB2FYk6fLmqDU457Y55zL9V98D2hRRtoKUl9cqoDnn0g5Md3LOfQdEm1l5j2P9g5lF4xvUhjnnvjjMJgH/WhythmB5LQ5wzu0ExgJnHHJXoI9Px0LjcfAI+DHgaIJlDAiF8RhCa0zWePzPbQK43nAYk4NiDDiaYBkDQmFMDqXxGIpmTA60BsZUoL6Z1TazGHwLfHx9yDZfA/39ly8EfnPOHXqMjZeOWsMhx16di+94p2DzNXC5f3XfDsAu59wGr0MdCzOrdODYKzNrh+//h4B6s/fnex9Y4Jx76QibBfRrkZcaguS1qGBmpf2XiwGnAgsP2SzQx6djofE4eAT0GJAXQTIGBP14DKExJms8DsrxGMJjTA74MSAvAn0MgNAYk0NhPIaiH5Oj8pmzUDjnss3sZuBHfCsVf+Ccm2dmjwPTnHNf43uRPzazpfgWn+njXeJ/ymMNt5rZuUA2vhqu8CzwEZjZp/hWvS1vZmuBR/AtyIJz7h3gO3wr+y4F9gJXepP0yPJQw4XADWaWDewD+gTgm/0JQD9gjvmOKwN4EKgBQfNa5KWGYHgtKgMfmVkkvjePkc65McE0Ph0LjceBQ+NxwAiF8RhCY0zWeBxk4zGExpgcCuMxaEwOIKEwHkMRj8kWePWLiIiIiIiIiPxdoB1CIiIiIiIiIiLyD2pgiIiIiIiIiEjAUwNDRERERERERAKeGhgiIiIiIiIiEvDUwBARERERERGRgKcGhoQVMyttZjd6nUNERDQmi4gECo3HEizUwJBwUxrQ4CwiEhhKozFZRCQQlEbjsQQBNTAk3DwD1DWzVDN73uswIiJhTmOyiEhg0HgsQcGcc15nECkyZlYLGOOca+Z1FhGRcKcxWUQkMGg8lmChGRgiIiIiIiIiEvDUwBARERERERGRgKcGhoSb3UBJr0OIiAigMVlEJFBoPJagoAaGhBXn3DbgTzObqwWKRES8pTFZRCQwaDyWYKFFPEVEREREREQk4GkGhoiIiIiIiIgEPDUwRERERERERCTgqYEhIiIiIiIiIgFPDQwRERERERERCXhqYIiIiIiIiIhIwFMDQ0REREREREQCnhoYIiIiIiIiIhLw/h/JWnSJDciCcAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -307,7 +308,7 @@ "metadata": {}, "outputs": [], "source": [ - "### Implementation for FDM:\n", + "# ## Implementation for FDM:\n", "\n", "# t = torch.linspace(t_min, t_max, 500).reshape(500, 1)\n", "# t_zero = torch.tensor([0.0])\n", @@ -330,13 +331,13 @@ "\n", "# ### Training loop\n", "# for k in range(train_iterations):\n", - "# ### TODO: implement loss computation of all equations\n", "# ### Loss for the differential equation: u_tt = D*(u_t)^2 - g\n", "# u = model(t)\n", - "# u_t = (u[1:-1] - u[2:])\n", - "# u_tt = (u[:-2] - 2*u[1:-1] + u[2:])\n", + "# u_ghost_node = torch.cat((u[1:2], u), dim=0)\n", + "# u_t = (u_ghost_node[2:] - u_ghost_node[:-2])/(2.0 * dt)\n", + "# u_tt = (u_ghost_node[2:] - 2*u_ghost_node[1:-1] + u_ghost_node[:-2]) / dt**2\n", "\n", - "# ode = u_tt - D*u_t**2 + g * dt**2\n", + "# ode = u_tt - D*u_t**2 + g\n", "\n", "# loss_ode = loss_fn_ode(ode, torch.zeros_like(ode))\n", "\n", @@ -358,7 +359,7 @@ "# ### Optimization step\n", "# optimizer.zero_grad()\n", "# total_loss.backward()\n", - "# optimizer.step()" + "# optimizer.step()\n" ] } ], From 0fe677d80ddeec1ffb7bada22c0cbbe2549ca6f9 Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Mon, 10 Jul 2023 15:51:41 +0200 Subject: [PATCH 25/30] Example for Workshop lecture Signed-off-by: Tom Freudenberg --- examples/workshop/Lecture_Example.py | 51 ++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 examples/workshop/Lecture_Example.py diff --git a/examples/workshop/Lecture_Example.py b/examples/workshop/Lecture_Example.py new file mode 100644 index 00000000..5061bc31 --- /dev/null +++ b/examples/workshop/Lecture_Example.py @@ -0,0 +1,51 @@ +import torchphysics as tp +import torch + +### Define Spaces +X = tp.spaces.R2('x') +U = tp.spaces.R1('u') + +### Define Domain +omega = tp.domains.Parallelogram(X, [0,0], [1,0], [0,1]) + +### Define Sampler (the location for the training) +inner_sampler = tp.samplers.RandomUniformSampler(omega, + n_points=15000) + +bound_sampler = tp.samplers.GridSampler(omega.boundary, + n_points=5000) + +### Define the neural network +model = tp.models.FCN(input_space=X, + output_space=U, + hidden=(20,20,20)) + +### Implement the math equations / condition +def pde_residual(u, x): + return tp.utils.laplacian(u, x) - 1.0 + +def boundary_residual(u, x): + return u - 0.0 + +### Combine the model, sampler and condition +boundary_cond = tp.conditions.PINNCondition(model, + bound_sampler, + boundary_residual) + +pde_cond = tp.conditions.PINNCondition(model, + inner_sampler, + pde_residual) + +### Start training +optim = tp.OptimizerSetting(torch.optim.Adam, lr=0.001) +solver = tp.solver.Solver([boundary_cond, pde_cond], optimizer_setting=optim) + +import pytorch_lightning as pl +trainer = pl.Trainer(gpus=1, # use one GPU + max_steps=3000) # iteration number +trainer.fit(solver) + +### Plot solution +plot_sampler = tp.samplers.PlotSampler(plot_domain=omega, + n_points=2000) +fig = tp.utils.plot(model, lambda u : u, plot_sampler) \ No newline at end of file From d1ba9dfcb03db75a723cb5fc979a78b3ce73df6a Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Mon, 10 Jul 2023 20:39:23 +0200 Subject: [PATCH 26/30] FEM Data for workshop Signed-off-by: Tom Freudenberg --- .../workshop/FEMData/Data2_2/space_coords.pt | Bin 0 -> 5099 bytes .../workshop/FEMData/Data2_2/temperature.pt | Bin 0 -> 90283 bytes .../workshop/FEMData/Data2_2/time_points.pt | Bin 0 -> 875 bytes examples/workshop/FEMData/Data2_3/D_data.pt | Bin 0 -> 2923 bytes .../workshop/FEMData/Data2_3/space_coords.pt | Bin 0 -> 5099 bytes .../workshop/FEMData/Data2_3/temperature.pt | Bin 0 -> 90283 bytes .../workshop/FEMData/Data2_3/time_points.pt | Bin 0 -> 875 bytes 7 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 examples/workshop/FEMData/Data2_2/space_coords.pt create mode 100644 examples/workshop/FEMData/Data2_2/temperature.pt create mode 100644 examples/workshop/FEMData/Data2_2/time_points.pt create mode 100644 examples/workshop/FEMData/Data2_3/D_data.pt create mode 100644 examples/workshop/FEMData/Data2_3/space_coords.pt create mode 100644 examples/workshop/FEMData/Data2_3/temperature.pt create mode 100644 examples/workshop/FEMData/Data2_3/time_points.pt diff --git a/examples/workshop/FEMData/Data2_2/space_coords.pt b/examples/workshop/FEMData/Data2_2/space_coords.pt new file mode 100644 index 0000000000000000000000000000000000000000..10840027547b3ebccb16ec6be8a7d54ad969f6dc GIT binary patch literal 5099 zcmd6r&u$x46vl7tG%+ShLs@0R0--2KkVMRmg*%F>Z0rhCgp_6zjAIw8R^73kY{|-~ zQg&hE3Zc9M3tnQffE7=`1|EX*`_A<=4oZbUrJZVO`_4Jv`ObIF{gY|d%ZnjYD&cR} zTDTKh!}d45lg{>0Yuws;`nbQhyBZGWuG3O`JTR-R!{c$UKdK%MJ6|97`bUT3&Xdt# zczE(jH4B@Y`^$zuGRxMZPPX7K)xG|pHU7c}t66D(!EAQ2@_yMq+fR?P#ryXb$JwpV z>*4t&M}F8lpK0OO?QY1={mCPhU*su&{G8`h{z>vv;cqeI?>OX}$UpMG3l9Fye<~dO zqizMxWxgUD$3vG5;l#YmE)|aFH5DE>QD@mpq6;0c!Hz-M60IG9f0qw|VzqYmb`VRq<@4(Obw;JTi<@WFsL7_P$#KKu@bDSVGZ zJ%aF~KIXq}cGLrXs7E4v;zZvRU-H1$^;uDz=*xJBoQyy5&>J86RJz%iI4K@+h=-5Y zBUfI|k@~`szF$#1;*eL=g69DYbo03Ah8Fa*^i*8(ay_Xp7}S^k%oP_~@-#RbV;-Ts z=7r)q$C3G|w%FMPX2a@FeEO3buk)R8#mB}Br6-utMsdL;u4B>%=&W8fdwS}j@y*3jE)ZucSk)i}*y2;^8?n&(RvKsI7X$FzGAmf>xUEHkQV*MjWI67}Gi_K5(=c zcB{|f!n_n8c=6pi@Et9fN7PHT(|0()#~{SVwa^?9A9zt0*Mhl-7Frwi9S*J;>n@tn zr_99}FKI-7>V}hZR2{_$UU1@upVteGa@7%z@Z*LbH=MY=pO{O`TlzHB4JU3mal?rl ze%v#Dh8fIG+P#?^PsxLI%Xp&Un^j}4_asG6_`x&Q7q03>uP=3{?;5HvW7LJgs)A zapM-xSl|D7Phw4+Fh}e@6VD_$7f<;4T)z-c_?ei&*B9oz)|gkiSNpoj{7A(Qp78T^ zX)2x}T!<&U;OD#=;uYtV*|V;*_Gw)=y#ID)@pY4V!CKC|U|l~4-(pS04_?$8KJfCr zLTeFYrk~bfo5MP@+B{}|_;+VDFsLIKJ`Y&WnFs94Q}Ke2&ll|nP-0v>-~$FaIR@(t z`vJWv4AvgQeEFG_oV?%3iGF8qq2G1>6d!niMSQzMtc&8q10Q&}w#;GnB%Pbc#q?sI zyz#89_>M_Gv-i@^VA9XzL_gC{oLjWs!bfq5?_62qu+ctib}#>%f!dO{!I{sQu!-xM z(x=pxKAoLU=m%=W8I&Gk?MG+&RC}-TBrZKf-oCc^-#TWmc-~X=Ur?UpM4rSY9x*&N z^H%2$#UUPXh=-o!NgU!4hj{kgFwvRyfw@jSIeXGqL2+C|`U;)VmP@(`pEy2O=_}>} zeKksn13q!UCywjJ*_wLk{AqUd$c6b)EBZkD4miRE-}RwiM#2XdeD6c{O!fuNMa)m_ znZoxzpkC_55Ook9xUK_za4KA{FMUW~Q4jiB=Rx7R-tgvJNqv>CaKQ6?(E&Z_E9!>c z^oh=I!t;EoFZG!JTi^3#KcP?PGxVe$Is*y^f6o`4xy0Y{QXQ=>nio+Ioo!S6@tf5h zugFvOu7~>B^3!@Ed;DA%>LNatuXMKhs1IfLB46_1x%OlGL>Ki>%tL>h>3P&aIPme` zte?zZ-mxrKO5gwX?bkE7o@3gMI0b1k1+;#m8*LCl!xvb84{%OCidT;Ms_r1#M_MGomcV76$+?(~K xrH`V~d*zP{b6$pV%|3tjpW#=7;4(knt%Yar@_z`tL~GV>E%Ci<|FC!4zW^8O-hBW7 literal 0 HcmV?d00001 diff --git a/examples/workshop/FEMData/Data2_2/temperature.pt b/examples/workshop/FEMData/Data2_2/temperature.pt new file mode 100644 index 0000000000000000000000000000000000000000..bcdeace37622e8c3faddf1d9f64c6bdbfb0f426d GIT binary patch literal 90283 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 z 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 literal 0 HcmV?d00001 diff --git a/examples/workshop/FEMData/Data2_2/time_points.pt b/examples/workshop/FEMData/Data2_2/time_points.pt new file mode 100644 index 0000000000000000000000000000000000000000..7f41c2b86e4e6387597653a615ef85524d75a194 GIT binary patch literal 875 zcmaLVL2DX86bJCPuC8VaDmeuLsi&f)RcS7{)ku)Q9Nbt6(u;1_MVBsFXLpnyJ%rLg z4jys{Arue!0Ldv=KZ5-RIfkBk$UXf}wRYEHM}7>mzW3bs9D}KGqEw3hSy|d7)3_-{_q3`DPOJ14No# zn=A7az2)MuZyyHNx z`yJc2I|q&>be<|S_=ezmgFh=8ESaj8o^CHuO)}PYnx>bLPD|xl^~Fk`k)}fj6qf5P z(FmqM6`~wepbaA!!vt<%3NyHepFsPVKV)GGa*&5I>_G(%!GI>Tp$C2V3?n#!uW$xq zIEM?kg2}#|L~eHbaE%|6)=wfs&zF-J+J1lu*Q(q98^x|JtAGF2eIG+*$zY1ymUk-r zA7tehk+pimRroCDO?WnJp;qo%d^=H4E eAF1)XN!hL@?>22L0#F&x5}JIb;v?hdvA+PLyQ)M0 literal 0 HcmV?d00001 diff --git a/examples/workshop/FEMData/Data2_3/D_data.pt b/examples/workshop/FEMData/Data2_3/D_data.pt new file mode 100644 index 0000000000000000000000000000000000000000..0d596563d4979ad6694e71f919d3e359a1d6284e GIT binary patch literal 2923 zcmdT`y^hmB5MIZ3`Pq|lr+WYjL=hxNA}A;jx>E#c48jB=r z9L>GRo8R}{gp2m|iRdJPPsCo|wp#5s&p&_vDD`05g}ruJFVpK_I38Wgb((2A4H#P; z)!)a*dM@O*)#}#azNlZMfjw2l{f=fG?LXnvxf`CR=bo=0-qXJu<*kks?(%mC`6?P4 zT(QPB9n?^`a-F}e^)K}5X{vVtu5NF8OUj}DOPZ(tHa)28@H9vLyx#eGt^NJwIW(re zPOpk4)u4WnUR}*HJ*t`YtG_Mq=!Ww!##L2;LGlSdWhFq z#FSYb4{~K3tm(K|E3~1>i zEWId}Gt_u=r_!*KPCXmvHiwhHemZ&9kP{Yc+cLnUGbNqC4xo@(`3W=6rag5t%%3u% z?7=Y4rMKG8aKCjn+>7tPwwlcw7oaQV%@hv9C@i#JRLCY=Ig$snE$i&57=~Ee+HFE) J$`9Zb_7}r>9FG71 literal 0 HcmV?d00001 diff --git a/examples/workshop/FEMData/Data2_3/space_coords.pt b/examples/workshop/FEMData/Data2_3/space_coords.pt new file mode 100644 index 0000000000000000000000000000000000000000..10840027547b3ebccb16ec6be8a7d54ad969f6dc GIT binary patch literal 5099 zcmd6r&u$x46vl7tG%+ShLs@0R0--2KkVMRmg*%F>Z0rhCgp_6zjAIw8R^73kY{|-~ zQg&hE3Zc9M3tnQffE7=`1|EX*`_A<=4oZbUrJZVO`_4Jv`ObIF{gY|d%ZnjYD&cR} zTDTKh!}d45lg{>0Yuws;`nbQhyBZGWuG3O`JTR-R!{c$UKdK%MJ6|97`bUT3&Xdt# zczE(jH4B@Y`^$zuGRxMZPPX7K)xG|pHU7c}t66D(!EAQ2@_yMq+fR?P#ryXb$JwpV z>*4t&M}F8lpK0OO?QY1={mCPhU*su&{G8`h{z>vv;cqeI?>OX}$UpMG3l9Fye<~dO zqizMxWxgUD$3vG5;l#YmE)|aFH5DE>QD@mpq6;0c!Hz-M60IG9f0qw|VzqYmb`VRq<@4(Obw;JTi<@WFsL7_P$#KKu@bDSVGZ zJ%aF~KIXq}cGLrXs7E4v;zZvRU-H1$^;uDz=*xJBoQyy5&>J86RJz%iI4K@+h=-5Y zBUfI|k@~`szF$#1;*eL=g69DYbo03Ah8Fa*^i*8(ay_Xp7}S^k%oP_~@-#RbV;-Ts z=7r)q$C3G|w%FMPX2a@FeEO3buk)R8#mB}Br6-utMsdL;u4B>%=&W8fdwS}j@y*3jE)ZucSk)i}*y2;^8?n&(RvKsI7X$FzGAmf>xUEHkQV*MjWI67}Gi_K5(=c zcB{|f!n_n8c=6pi@Et9fN7PHT(|0()#~{SVwa^?9A9zt0*Mhl-7Frwi9S*J;>n@tn zr_99}FKI-7>V}hZR2{_$UU1@upVteGa@7%z@Z*LbH=MY=pO{O`TlzHB4JU3mal?rl ze%v#Dh8fIG+P#?^PsxLI%Xp&Un^j}4_asG6_`x&Q7q03>uP=3{?;5HvW7LJgs)A zapM-xSl|D7Phw4+Fh}e@6VD_$7f<;4T)z-c_?ei&*B9oz)|gkiSNpoj{7A(Qp78T^ zX)2x}T!<&U;OD#=;uYtV*|V;*_Gw)=y#ID)@pY4V!CKC|U|l~4-(pS04_?$8KJfCr zLTeFYrk~bfo5MP@+B{}|_;+VDFsLIKJ`Y&WnFs94Q}Ke2&ll|nP-0v>-~$FaIR@(t z`vJWv4AvgQeEFG_oV?%3iGF8qq2G1>6d!niMSQzMtc&8q10Q&}w#;GnB%Pbc#q?sI zyz#89_>M_Gv-i@^VA9XzL_gC{oLjWs!bfq5?_62qu+ctib}#>%f!dO{!I{sQu!-xM z(x=pxKAoLU=m%=W8I&Gk?MG+&RC}-TBrZKf-oCc^-#TWmc-~X=Ur?UpM4rSY9x*&N z^H%2$#UUPXh=-o!NgU!4hj{kgFwvRyfw@jSIeXGqL2+C|`U;)VmP@(`pEy2O=_}>} zeKksn13q!UCywjJ*_wLk{AqUd$c6b)EBZkD4miRE-}RwiM#2XdeD6c{O!fuNMa)m_ znZoxzpkC_55Ook9xUK_za4KA{FMUW~Q4jiB=Rx7R-tgvJNqv>CaKQ6?(E&Z_E9!>c z^oh=I!t;EoFZG!JTi^3#KcP?PGxVe$Is*y^f6o`4xy0Y{QXQ=>nio+Ioo!S6@tf5h zugFvOu7~>B^3!@Ed;DA%>LNatuXMKhs1IfLB46_1x%OlGL>Ki>%tL>h>3P&aIPme` zte?zZ-mxrKO5gwX?bkE7o@3gMI0b1k1+;#m8*LCl!xvb84{%OCidT;Ms_r1#M_MGomcV76$+?(~K xrH`V~d*zP{b6$pV%|3tjpW#=7;4(knt%Yar@_z`tL~GV>E%Ci<|FC!4zW^8O-hBW7 literal 0 HcmV?d00001 diff --git a/examples/workshop/FEMData/Data2_3/temperature.pt b/examples/workshop/FEMData/Data2_3/temperature.pt new file mode 100644 index 0000000000000000000000000000000000000000..10598d45f2ec7c1dc25cd8c097929ea6be9df7ae GIT binary patch literal 90283 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 z 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 D&N7Gb literal 0 HcmV?d00001 diff --git a/examples/workshop/FEMData/Data2_3/time_points.pt b/examples/workshop/FEMData/Data2_3/time_points.pt new file mode 100644 index 0000000000000000000000000000000000000000..7f41c2b86e4e6387597653a615ef85524d75a194 GIT binary patch literal 875 zcmaLVL2DX86bJCPuC8VaDmeuLsi&f)RcS7{)ku)Q9Nbt6(u;1_MVBsFXLpnyJ%rLg z4jys{Arue!0Ldv=KZ5-RIfkBk$UXf}wRYEHM}7>mzW3bs9D}KGqEw3hSy|d7)3_-{_q3`DPOJ14No# zn=A7az2)MuZyyHNx z`yJc2I|q&>be<|S_=ezmgFh=8ESaj8o^CHuO)}PYnx>bLPD|xl^~Fk`k)}fj6qf5P z(FmqM6`~wepbaA!!vt<%3NyHepFsPVKV)GGa*&5I>_G(%!GI>Tp$C2V3?n#!uW$xq zIEM?kg2}#|L~eHbaE%|6)=wfs&zF-J+J1lu*Q(q98^x|JtAGF2eIG+*$zY1ymUk-r zA7tehk+pimRroCDO?WnJp;qo%d^=H4E eAF1)XN!hL@?>22L0#F&x5}JIb;v?hdvA+PLyQ)M0 literal 0 HcmV?d00001 From 1bc3da515df85c0aa7e579863b5c6b589c24eef9 Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Wed, 12 Jul 2023 10:39:33 +0200 Subject: [PATCH 27/30] Update dataset for workshop examples Signed-off-by: Tom Freudenberg --- examples/workshop/FEMData/Data2_3/D_data.pt | Bin 2923 -> 0 bytes .../workshop/FEMData/Data2_3/space_coords.pt | Bin 5099 -> 1259 bytes .../workshop/FEMData/Data2_3/temperature.pt | Bin 90283 -> 0 bytes .../workshop/FEMData/Data2_3/time_points.pt | Bin 875 -> 1515 bytes .../workshop/FEMData/Data2_3/wave_data.pt | Bin 0 -> 105259 bytes 5 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 examples/workshop/FEMData/Data2_3/D_data.pt delete mode 100644 examples/workshop/FEMData/Data2_3/temperature.pt create mode 100644 examples/workshop/FEMData/Data2_3/wave_data.pt diff --git a/examples/workshop/FEMData/Data2_3/D_data.pt b/examples/workshop/FEMData/Data2_3/D_data.pt deleted file mode 100644 index 0d596563d4979ad6694e71f919d3e359a1d6284e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2923 zcmdT`y^hmB5MIZ3`Pq|lr+WYjL=hxNA}A;jx>E#c48jB=r z9L>GRo8R}{gp2m|iRdJPPsCo|wp#5s&p&_vDD`05g}ruJFVpK_I38Wgb((2A4H#P; z)!)a*dM@O*)#}#azNlZMfjw2l{f=fG?LXnvxf`CR=bo=0-qXJu<*kks?(%mC`6?P4 zT(QPB9n?^`a-F}e^)K}5X{vVtu5NF8OUj}DOPZ(tHa)28@H9vLyx#eGt^NJwIW(re zPOpk4)u4WnUR}*HJ*t`YtG_Mq=!Ww!##L2;LGlSdWhFq z#FSYb4{~K3tm(K|E3~1>i zEWId}Gt_u=r_!*KPCXmvHiwhHemZ&9kP{Yc+cLnUGbNqC4xo@(`3W=6rag5t%%3u% z?7=Y4rMKG8aKCjn+>7tPwwlcw7oaQV%@hv9C@i#JRLCY=Ig$snE$i&57=~Ee+HFE) J$`9Zb_7}r>9FG71 diff --git a/examples/workshop/FEMData/Data2_3/space_coords.pt b/examples/workshop/FEMData/Data2_3/space_coords.pt index 10840027547b3ebccb16ec6be8a7d54ad969f6dc..8d0412c90b09af2b76fc995636606592fd90ce1e 100644 GIT binary patch literal 1259 zcma*ne`pd>902gAZq9C`V}yV8gAj&`(yd^{+U83_kRxV}kuAyeJe(xDJ5PfKV>Kui z1VIo~G$dIP1pN^dK@bcgWDqRY7>zNIF{oHX|MpMc?^h?DG3d#McjtY-@80+E-UUQc z3u6`w`=@oVP8L-*HE}iN^IF-Mu1y;yEdx=mNKQ+pvO+|aW4UB19?|4< zHls%J#|4EsouM`uKMRr3gsd2}vMR^VCM8W!EZsq6kERGgrQH<}+bnyFU)duV z4Fz_s)XI+NDs}hxyj@Lo>WXf-S+kWndi>)934dJRXn*lNS)Y2x(cIWua=Gs{M~6CJ zk&W$_92Lqh$d&o$938&#j8wu!j-H+>5NY2NjvT)plFh{j9L<;R6M5zyM_rM-WUK!U zMPmEIUf7rtF0tA$aHE{2B5n#~XO`=Mqp zS)Uq!dIzA!KC-dxhWgx4Q#YxE9Z-)0YB)eP7ws^AJIuL*Z1oE;UjgQ5B1)`a&LIS2 z6BuI%L2ONV5S|Uf#-fJ1?OLh(oW%&I3GBYxZ0vM>x8-Fu3%l6oJ^7#8tzqX?FHZ>g z=B2sBD7=)RfM~$3ex@7GKnFh1wdNDvoZVQHRhRi4?i#b*Jf!h?z_!!Bsot{BwLc&azb$MQK4aMMBN7l>&3J8sAI4W>{{kV3hL8XN literal 5099 zcmd6r&u$x46vl7tG%+ShLs@0R0--2KkVMRmg*%F>Z0rhCgp_6zjAIw8R^73kY{|-~ zQg&hE3Zc9M3tnQffE7=`1|EX*`_A<=4oZbUrJZVO`_4Jv`ObIF{gY|d%ZnjYD&cR} zTDTKh!}d45lg{>0Yuws;`nbQhyBZGWuG3O`JTR-R!{c$UKdK%MJ6|97`bUT3&Xdt# zczE(jH4B@Y`^$zuGRxMZPPX7K)xG|pHU7c}t66D(!EAQ2@_yMq+fR?P#ryXb$JwpV z>*4t&M}F8lpK0OO?QY1={mCPhU*su&{G8`h{z>vv;cqeI?>OX}$UpMG3l9Fye<~dO zqizMxWxgUD$3vG5;l#YmE)|aFH5DE>QD@mpq6;0c!Hz-M60IG9f0qw|VzqYmb`VRq<@4(Obw;JTi<@WFsL7_P$#KKu@bDSVGZ zJ%aF~KIXq}cGLrXs7E4v;zZvRU-H1$^;uDz=*xJBoQyy5&>J86RJz%iI4K@+h=-5Y zBUfI|k@~`szF$#1;*eL=g69DYbo03Ah8Fa*^i*8(ay_Xp7}S^k%oP_~@-#RbV;-Ts z=7r)q$C3G|w%FMPX2a@FeEO3buk)R8#mB}Br6-utMsdL;u4B>%=&W8fdwS}j@y*3jE)ZucSk)i}*y2;^8?n&(RvKsI7X$FzGAmf>xUEHkQV*MjWI67}Gi_K5(=c zcB{|f!n_n8c=6pi@Et9fN7PHT(|0()#~{SVwa^?9A9zt0*Mhl-7Frwi9S*J;>n@tn zr_99}FKI-7>V}hZR2{_$UU1@upVteGa@7%z@Z*LbH=MY=pO{O`TlzHB4JU3mal?rl ze%v#Dh8fIG+P#?^PsxLI%Xp&Un^j}4_asG6_`x&Q7q03>uP=3{?;5HvW7LJgs)A zapM-xSl|D7Phw4+Fh}e@6VD_$7f<;4T)z-c_?ei&*B9oz)|gkiSNpoj{7A(Qp78T^ zX)2x}T!<&U;OD#=;uYtV*|V;*_Gw)=y#ID)@pY4V!CKC|U|l~4-(pS04_?$8KJfCr zLTeFYrk~bfo5MP@+B{}|_;+VDFsLIKJ`Y&WnFs94Q}Ke2&ll|nP-0v>-~$FaIR@(t z`vJWv4AvgQeEFG_oV?%3iGF8qq2G1>6d!niMSQzMtc&8q10Q&}w#;GnB%Pbc#q?sI zyz#89_>M_Gv-i@^VA9XzL_gC{oLjWs!bfq5?_62qu+ctib}#>%f!dO{!I{sQu!-xM z(x=pxKAoLU=m%=W8I&Gk?MG+&RC}-TBrZKf-oCc^-#TWmc-~X=Ur?UpM4rSY9x*&N z^H%2$#UUPXh=-o!NgU!4hj{kgFwvRyfw@jSIeXGqL2+C|`U;)VmP@(`pEy2O=_}>} zeKksn13q!UCywjJ*_wLk{AqUd$c6b)EBZkD4miRE-}RwiM#2XdeD6c{O!fuNMa)m_ znZoxzpkC_55Ook9xUK_za4KA{FMUW~Q4jiB=Rx7R-tgvJNqv>CaKQ6?(E&Z_E9!>c z^oh=I!t;EoFZG!JTi^3#KcP?PGxVe$Is*y^f6o`4xy0Y{QXQ=>nio+Ioo!S6@tf5h zugFvOu7~>B^3!@Ed;DA%>LNatuXMKhs1IfLB46_1x%OlGL>Ki>%tL>h>3P&aIPme` zte?zZ-mxrKO5gwX?bkE7o@3gMI0b1k1+;#m8*LCl!xvb84{%OCidT;Ms_r1#M_MGomcV76$+?(~K xrH`V~d*zP{b6$pV%|3tjpW#=7;4(knt%Yar@_z`tL~GV>E%Ci<|FC!4zW^8O-hBW7 diff --git a/examples/workshop/FEMData/Data2_3/temperature.pt b/examples/workshop/FEMData/Data2_3/temperature.pt deleted file mode 100644 index 10598d45f2ec7c1dc25cd8c097929ea6be9df7ae..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 90283 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 z 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 D&N7Gb diff --git a/examples/workshop/FEMData/Data2_3/time_points.pt b/examples/workshop/FEMData/Data2_3/time_points.pt index 7f41c2b86e4e6387597653a615ef85524d75a194..59decc40efa10ac378fd50b2ea110047b0811b57 100644 GIT binary patch literal 1515 zcmaLXUr19?9Ki82r*qyyEhCbmKO~}MYTbyWa+}2}uGG{Dt!S?O(cy63?QSGRtbdke zwf?tdCImsyLl6`}4?++~Gx`HT&_fUeMGt`x1U>Y`JCVHa1Y#b9Evet z2(wxIQ%c2L;R?CC{ZVh7$ECSy`+5TQred)-tHko$T9Bw(XGHS{!jd!OJs9x^JWkEq z8xDq?(KV7Ps;b%xSwBpqtIMkz(kYTX5Ois6X_VBwb^|f>s+XxF`O3Ja7PKfr z8CMJgs!1{EP2r&19Sj7#Zp|O;4NE&i9&gC&+2VI=l4`DQRf{xLYE@^|I+Q|lG7{gK zWHr4yX54A9Sdq2Ux_Wz4WzIgcHk~nGVKI?PZJJ0mHzpH_M*5AAC7CF<$g*s~Ek2*m zB1DY-5T0OskGV(K7?#35U|+CFOjvzBlXW6B+bYXtR@Si!u@tMsYA_jVz^s@ZYsT8J z4y+UNVF4_R^6Hg!N;Gu_M?~EJi?C#y8^BIuXRtHaAa)iz zhYevv*m>*%b`gtXaqJRy8M}gA#jax4u?U>-OJGUt7B-9xW4Eyp><%_+(@$dm ztC#T#4z^xrK8Yn_$@EE#dP8AOxV>rN|Bj+8>8rmP>DrygucTLpV$hrEJ1z4LDAgyj zO70Dpo1OXH#aWr(7-eSH)#v7BepN|UuEw1^mHT&}4#i}u`5Uy@xN16FzYO&<)jmlN f#aoup3wiq8Dh3Pmw-5%ZLn$!neIt(^pN{ zB*Grzi8$~uL4+6yzOYAzADke*h=m54aL`5%*YI$M5Mxa6glEhV^|_XK!3r_n@qtey zei)dRlcmQk(+ceUsy%AOSJXkfsa|TTqYul!B{kRmtA{eJoG>uV;mn diff --git a/examples/workshop/FEMData/Data2_3/wave_data.pt b/examples/workshop/FEMData/Data2_3/wave_data.pt new file mode 100644 index 0000000000000000000000000000000000000000..dd236aa49ab0e4258d71075e6c0e9c6b68f52c93 GIT binary patch literal 105259 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

l5z{7JI&Y;MHI*)<3!Hh+diHZ3=W`$TGY|7I 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 Date: Thu, 13 Jul 2023 09:02:30 +0200 Subject: [PATCH 28/30] Complete workshop examples Signed-off-by: Tom Freudenberg --- README.rst | 5 +- examples/workshop/Exercise2_1.ipynb | 5 +- examples/workshop/Exercise2_2.ipynb | 64 ++- examples/workshop/Exercise2_3.ipynb | 276 +++++++++++ examples/workshop/Exercise3_1.ipynb | 377 +++------------ examples/workshop/Exercise3_2.ipynb | 672 +++++++++++++++++++++++++++ examples/workshop/Sol2_2.ipynb | 89 ++-- examples/workshop/Sol2_3.ipynb | 472 +++++++++++++++++++ examples/workshop/Sol3_1.ipynb | 298 ++++++++++++ examples/workshop/Sol3_2.ipynb | 681 ++++++++++++++++++++++++++++ 10 files changed, 2584 insertions(+), 355 deletions(-) create mode 100644 examples/workshop/Exercise2_3.ipynb create mode 100644 examples/workshop/Exercise3_2.ipynb create mode 100644 examples/workshop/Sol2_3.ipynb create mode 100644 examples/workshop/Sol3_1.ipynb create mode 100644 examples/workshop/Sol3_2.ipynb diff --git a/README.rst b/README.rst index e1bbd219..7baa893f 100644 --- a/README.rst +++ b/README.rst @@ -101,12 +101,13 @@ with the option ``all``: If you want to add functionalities or modify the code. We recommend copying the -repository and install it locally: +repository and installing it locally: .. code-block:: python git clone https://github.com/boschresearch/torchphysics - pip install . + cd path_to_torchphysics_folder + pip install .[all] .. _Numpy: https://numpy.org/ .. _Matplotlib: https://matplotlib.org/ diff --git a/examples/workshop/Exercise2_1.ipynb b/examples/workshop/Exercise2_1.ipynb index df6fbaa3..5a2e7ec5 100644 --- a/examples/workshop/Exercise2_1.ipynb +++ b/examples/workshop/Exercise2_1.ipynb @@ -31,6 +31,7 @@ } ], "source": [ + "!pip install torchaudio==0.13.0\n", "!pip install torchphysics\n", "\n", "# This will give some error messages, because some package on Google colab use newer versions than we need.\n", @@ -67,7 +68,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Using the [lecture example](https://github.com/TomF98/torchphysics/tree/main/examples) gives a good guide for working with TorchPhysics." + "Using the [lecture example](https://github.com/TomF98/torchphysics/blob/main/examples/workshop/Lecture_Example.py) gives a good guide for working with TorchPhysics." ] }, { @@ -92,7 +93,7 @@ "metadata": {}, "outputs": [], "source": [ - "### TODO: Create the neural network\n", + "### TODO: Create the neural network with 2 hidden layers and 20 neurons each.\n", "model = ..." ] }, diff --git a/examples/workshop/Exercise2_2.ipynb b/examples/workshop/Exercise2_2.ipynb index af0e2b20..be28496d 100644 --- a/examples/workshop/Exercise2_2.ipynb +++ b/examples/workshop/Exercise2_2.ipynb @@ -18,7 +18,7 @@ "\\end{align*}\n", "\n", "The above system describes an isolated room $\\Omega$, with a \\\\\n", - "heater at the wall $\\partial\\Omega_{Heater} = \\{(x, y) | 1\\leq x\\leq 3, y=4\\}$. We set $I=[0, 20]$, $D=1$, the initial temperature to $u_0 = 16$\\,\\degree C and the temperature of the heater is defined below.\n", + "heater at the wall $\\partial\\Omega_{Heater} = \\{(x, y) | 1\\leq x\\leq 3, y=4\\}$. We set $I=[0, 20]$, $D=1$, the initial temperature to $u_0 = 16\\degree C$ and the temperature of the heater is defined below.\n", "\n", "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell. Since the installation can take around 2 minutes and has to be redone if you switch to the GPU later." ] @@ -29,6 +29,7 @@ "metadata": {}, "outputs": [], "source": [ + "!pip install torchaudio==0.13.0\n", "!pip install torchphysics" ] }, @@ -76,13 +77,13 @@ "plt.grid()\n", "plt.title(\"temperature of the heater over time\")\n", "\n", - "# Number of time points \n", + "# Number of training points \n", "N_pde = 15000\n", "N_initial = 5000\n", "N_boundary = 5000\n", "\n", "# Training parameters\n", - "train_iterations = 5000\n", + "train_iterations = 10000\n", "learning_rate = 1.e-3" ] }, @@ -103,7 +104,9 @@ "outputs": [], "source": [ "### TODO: Implement the spaces\n", - "\n", + "X = ...\n", + "T = ...\n", + "U = ...\n", "\n", "### TODO: Define the domain omega and time interval \n", "Omega = ...\n", @@ -136,7 +139,7 @@ "metadata": {}, "outputs": [], "source": [ - "### TODO: Create the neural network with 3 hidden layers and 50 neurons each.\n", + "### TODO: Create the neural network with 4 hidden layers and 30 neurons each.\n", "model = ..." ] }, @@ -174,7 +177,7 @@ "outputs": [], "source": [ "### TODO: Define condition for the boundary conditions:\n", - "### Already implemented is a filltering, to determine on what part the points are\n", + "### Already implemented is a filltering, to determine where the points are\n", "### on the boundary, and the normal vector computation.\n", "### For the normal derivative use: tp.utils.normal_derivative\n", "def boundary_residual(u, t, x):\n", @@ -232,7 +235,54 @@ "anim_sampler = tp.samplers.AnimationSampler(Omega, I, 200, n_points=1000)\n", "fig, anim = tp.utils.animate(model, lambda u: u, anim_sampler, ani_speed=10, angle=[30, 220])\n", "anim.save('heat-eq.gif')\n", - "# On Google colab you have at the left side a tab with a folder. There you should find the gif and watch it." + "# On Google colab you have at the left side a tab with a folder. There you can find the gif and can watch it." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also compare the solution with data obtained with a finite element method. First we load the data from GitHub:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!wget https://github.com/TomF98/torchphysics/raw/main/examples/workshop/FEMData/Data2_2/time_points.pt\n", + "!wget https://github.com/TomF98/torchphysics/raw/main/examples/workshop/FEMData/Data2_2/space_coords.pt\n", + "!wget https://github.com/TomF98/torchphysics/raw/main/examples/workshop/FEMData/Data2_2/temperature.pt" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, read the data and compare it with the network output:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fe_time = torch.load(\"time_points.pt\")\n", + "fe_space = torch.load(\"space_coords.pt\")\n", + "fe_temperature = torch.load(\"temperature.pt\")\n", + "\n", + "in_data = torch.zeros((len(fe_time), len(fe_space), 3))\n", + "in_data[:, :, :2] = fe_space\n", + "in_data[:, :, 2] = fe_time.repeat(1, len(fe_space))\n", + "\n", + "model_out = model(tp.spaces.Points(in_data, X*T))\n", + "error = torch.abs(model_out.as_tensor - fe_temperature)\n", + "print(\"Max. absolute error between FE and PINN:\", torch.max(error))\n", + "print(\"Relative error is:\", torch.max(error)/torch.max(fe_temperature))" ] } ], diff --git a/examples/workshop/Exercise2_3.ipynb b/examples/workshop/Exercise2_3.ipynb new file mode 100644 index 00000000..f384d637 --- /dev/null +++ b/examples/workshop/Exercise2_3.ipynb @@ -0,0 +1,276 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 2\n", + "\n", + "#### 2.3 Solving an inverse Problem with TorchPhysics\n", + "We consider now the wave equation\n", + "\n", + "\\begin{align*}\n", + " \\partial_t^2 u &= c \\, \\partial_x^2 u, &&\\text{ in } I_x \\times I_t, \\\\\n", + " u &= 0 , &&\\text{ on } \\partial I_x \\times I_t, \\\\\n", + " \\partial_t u &= 0 , &&\\text{ on } \\partial I_x \\times I_t, \\\\\n", + " u(\\cdot, 0) &= \\sin(x) , &&\\text{ in } I_x,\n", + "\\end{align*}\n", + "\n", + "with $I_x = [0, 2\\pi]$ and $I_t = [0, 20]$. We are given a noisy dataset $\\{(u_i, x_i, t_i)\\}_{i=1}^N$ and aim to determine the corresponding value of $c$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install torchaudio==0.13.0\n", + "!pip install torchphysics" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torchphysics as tp\n", + "import pytorch_lightning as pl\n", + "import torch\n", + "import math\n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 20.0\n", + "width = 2 * math.pi \n", + "\n", + "# Number of training points \n", + "N_pde = 20000\n", + "\n", + "# Training parameters\n", + "train_iterations = 5000\n", + "learning_rate = 1.e-3" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Implement the spaces\n", + "\n", + "\n", + "### TODO: Define the domain omega and time interval \n", + "I_x = ...\n", + "I_t = ...\n", + "\n", + "### TODO: Create sampler for the PDE condition inside I_x x I_t\n", + "pde_sampler = ..." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Create the neural networks for the solution u and the learnable parameter c.\n", + "### The model of u should contain 3 hidden layers with 50 neurons each and should have\n", + "### X*T as an input space (order is important for the following cells).\n", + "### For the parameter c use `tp.models.Parameter` and the initial value 1.0\n", + "model_u = ...\n", + "param_C = ..." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the wave equation. Parameters can be passed to the condition\n", + "### with the `parameter` keyword.\n", + "def pde_residual():\n", + " pass\n", + "\n", + "pde_condition = ..." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Here, we load the data. First download it from GitHub and then read it with\n", + "### PyTorch. `in_data` contains combinations of X*T points and 'out_data' the \n", + "### coressponding ampltidue of the wave.\n", + "\n", + "!wget https://github.com/TomF98/torchphysics/raw/main/examples/workshop/FEMData/Data2_3/time_points.pt\n", + "!wget https://github.com/TomF98/torchphysics/raw/main/examples/workshop/FEMData/Data2_3/space_coords.pt\n", + "!wget https://github.com/TomF98/torchphysics/raw/main/examples/workshop/FEMData/Data2_3/wave_data.pt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fe_time = torch.load(\"time_points.pt\")\n", + "fe_space = torch.load(\"space_coords.pt\")\n", + "out_data = torch.load(\"wave_data.pt\")\n", + "\n", + "in_data = torch.zeros((len(fe_time), len(fe_space), 2))\n", + "in_data[:, :, :1] = fe_space\n", + "in_data[:, :, 1] = fe_time\n", + "\n", + "in_data = in_data.reshape(-1, 2)\n", + "\n", + "print(\"Data has the shape:\")\n", + "print(in_data.shape, out_data.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Randomly shuffle the data from the previous cell, add 1% of articfical noise to the `out_data`\n", + "### and then select for the training only the first half of the data batch.\n", + "### Hint: for the random shuffle `torch.randperm` is useful and for constructing noise \n", + "### use: `0.01 * torch.randn_like(out_data) * out_data`\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Transform the data from the previous cell into `tp.spaces.Points` objects, to\n", + "### assign them a space and enable TorchPhysics to work with them:\n", + "in_data_points = ...\n", + "out_data_points = ...\n", + "\n", + "### Here we create a DataLoader, that passes the above data to the conditions and\n", + "### also controls the batch size, the device (CPU or GPU) and more...\n", + "### And also the condition, that fits the given model to the data\n", + "data_loader = tp.utils.PointsDataLoader((in_data_points, out_data_points), batch_size=len(in_data))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "### Data condition, that fits the model to the given data:\n", + "data_condition = tp.conditions.DataCondition(module=model_u,\n", + " dataloader=data_loader,\n", + " norm=2, use_full_dataset=True,\n", + " weight=100) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Start training with Adam:\n", + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate)\n", + "solver = tp.solver.Solver(train_conditions=[data_condition, pde_condition], optimizer_setting=optim)\n", + "\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " max_steps=train_iterations,\n", + " logger=False,\n", + " benchmark=True)\n", + " \n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### For better results in the inverse problem, switching to LBFGS is useful:\n", + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.LBFGS, lr=0.5, optimizer_args={'max_iter': 2})\n", + "pde_condition.sampler = pde_condition.sampler.make_static()\n", + "solver = tp.solver.Solver([pde_condition, data_condition], optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " max_steps=2000,\n", + " logger=False,\n", + " benchmark=True)\n", + " \n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Correct value of c is: 0.742\")\n", + "print(\"With PINNs we computed the value:\", param_C.as_tensor.item())\n", + "print(\"Relative difference is:\", abs(0.742 - param_C.as_tensor.item()) / 0.742)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### We can also plot the solution that we learned\n", + "plot_domain = tp.domains.Parallelogram(X*T, [0, 0], [width, 0], [0, t_max])\n", + "plot_sampler = tp.samplers.PlotSampler(plot_domain, 1000)\n", + "fig = tp.utils.plot(model_u, lambda u: u, plot_sampler, plot_type=\"contour_surface\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Or an animation:\n", + "anim_sampler = tp.samplers.AnimationSampler(I_x, I_t, 200, n_points=250)\n", + "fig, anim = tp.utils.animate(model_u, lambda u: u, anim_sampler, ani_speed=40)\n", + "anim.save('wave-eq.gif')\n", + "# On Google colab you have at the left side a tab with a folder. There you should find the gif and can watch it." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/Exercise3_1.ipynb b/examples/workshop/Exercise3_1.ipynb index d20bd690..7a5b14cd 100644 --- a/examples/workshop/Exercise3_1.ipynb +++ b/examples/workshop/Exercise3_1.ipynb @@ -7,16 +7,14 @@ "source": [ "### Exercise Sheet 3\n", "\n", - "#### 3.1 Learning the Solution Operator\n", - "Use TorchPhysics and DeepONets to solve the ODE with time dependent $D(t)$:\n", - "\n", + "#### 3.1 ODE with a time dependent Parameter\n", + "Use TorchPhysics to solve the ODE for falling with a parachute:\n", "\\begin{align*}\n", " \\partial_t^2 u(t) &= D(t)(\\partial_t u(t))^2 - g \\\\\n", " u(0) &= H \\\\\n", " \\partial_t u(0) &= 0\n", "\\end{align*}\n", - "\n", - "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell. Since the installation can take around 2 minutes and has to be redone if you switch to the GPU later." + "Where now $D: \\R \\to \\R$ with $ D(t) = 2.0\\cdot(1.0 + \\sin(4\\cdot t))$." ] }, { @@ -25,7 +23,8 @@ "metadata": {}, "outputs": [], "source": [ - "!pip install torchphysics" + "!pip install torchaudio==0.13.0\n", + "!pip install torchphysics\n" ] }, { @@ -40,17 +39,19 @@ "\n", "# Here all parameters are defined:\n", "t_min, t_max = 0.0, 3.0\n", + "\n", + "### TODO: implement the function of D.\n", + "def D(t):\n", + " pass\n", + "\n", "g, H = 9.81, 50.0\n", - "D_min, D_max = 0.005, 5.0\n", - "# Size of the data set\n", - "data_batch = 12000\n", "\n", - "# Number of time points for discretization of D and training\n", - "N_t = 60\n", + "# number of time points \n", + "N_t = 500\n", + "N_initial = 1\n", "\n", - "# Training parameters\n", - "train_iterations = 7500\n", - "learning_rate = 5.e-4" + "train_iterations = 10000\n", + "learning_rate = 1.e-3" ] }, { @@ -59,95 +60,24 @@ "metadata": {}, "outputs": [], "source": [ - "# Function that uses backward Euler to create the dataset (you dont have to understand this cell):\n", - "def data_create_fn(N_t, data_batch, start_height):\n", - " # Time grid (Trunk input)\n", - " t = torch.linspace(0, 3.0, 60)\n", - " dt = t[1] - t[0]\n", - " # Tensors for Branch input and expected output\n", - " D_fn = torch.zeros((data_batch, len(t), 1))\n", - " u = torch.zeros((data_batch, len(t), 1))\n", - " v = torch.zeros((data_batch, len(t), 1))\n", - " \n", - " # Create different fuction types for D_fn:\n", - " # First batch are step functions:\n", - " ind = int(data_batch / 3.0)\n", - " random_steps = D_min + (D_max - D_min) * torch.rand((ind, 6, 1))\n", - " D_fn[:ind, :] = random_steps.repeat_interleave(int(N_t/6), dim=1)\n", - " # Second batch are sinus functions:\n", - " random_fre_amp = D_min + (D_max - D_min) * torch.rand((ind, 1, 2))\n", - " random_fre_amp = random_fre_amp.repeat_interleave(N_t, dim=1)\n", - " sin_fn = random_fre_amp[:, :, 1]/2.0 * (D_min + 1 + torch.sin(random_fre_amp[:, :, 0] * t))\n", - " D_fn[ind:2*ind, :] = sin_fn.unsqueeze(-1)\n", - " # Last batch is exp functions:\n", - " missing_idx = data_batch - 2*ind\n", - " random_start_sloope = (D_max - D_min) * torch.rand((missing_idx, 1, 2))\n", - " random_start_sloope = random_start_sloope.repeat_interleave(N_t, dim=1)\n", - " exp_fn = D_min + random_start_sloope[:, :, 1] * torch.exp(-random_start_sloope[:, :, 0] * t)\n", - " D_fn[2*ind:, :] = exp_fn.unsqueeze(-1)\n", - " # flip some exp functions around t=1.5:\n", - " D_fn[int(2*ind + missing_idx/2.0):, :] = torch.flip(D_fn[int(2*ind + missing_idx/2.0):, :, :], dims=(1,))\n", - " \n", - " # Do time stepping to compute solution\n", - " u[:, 0] = start_height\n", - " for i in range(len(t)-1):\n", - " v[:, i+1] = 1/(2*dt*D_fn[:, i+1]) - torch.sqrt(1/(2*dt*D_fn[:, i+1])**2 - (v[:, i] - dt*g)/(dt*D_fn[:, i+1]))\n", - " u[:, i+1] = u[:, i] + dt * v[:, i+1]\n", + "### Spaces, Domains and Sampler like yesterday:\n", + "T = tp.spaces.R1('t')\n", + "U = tp.spaces.R1('u')\n", + " \n", + "int_t = tp.domains.Interval(T, t_min, t_max)\n", "\n", - " return t.reshape(-1, 1), u, D_fn[:, ::2, :]" + "ode_sampler = tp.samplers.RandomUniformSampler(int_t, n_points=N_t)\n", + "initial_sampler = tp.samplers.RandomUniformSampler(int_t.boundary_left, n_points=N_initial)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Here we create the data\n", - "t_tensor, u_tensor, D_tensor = data_create_fn(N_t, data_batch, H)\n", - "\n", - "# Show an example plot\n", - "import matplotlib.pyplot as plt\n", - "plt.figure(figsize=(16, 4))\n", - "plt.subplot(1, 2, 1)\n", - "plt.plot(t_tensor[::2], D_tensor[0])\n", - "plt.plot(t_tensor[::2], D_tensor[4000])\n", - "plt.plot(t_tensor[::2], D_tensor[8000])\n", - "plt.ylabel(\"D\")\n", - "plt.xlabel(\"t\")\n", - "plt.grid()\n", - "plt.subplot(1, 2, 2)\n", - "plt.plot(t_tensor, u_tensor[0])\n", - "plt.plot(t_tensor, u_tensor[4000])\n", - "plt.plot(t_tensor, u_tensor[8000])\n", - "plt.ylabel(\"u\")\n", - "plt.xlabel(\"t\")\n", - "plt.title(\"Solution for corresponding D\")\n", - "plt.grid()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, + "outputs": [], "source": [ - "#### a) Shuffle and Split Data \n", - "The above data is created in ordered way (e.g. first 4000 entries belong to step functions). Randomly permute the tensors of $u$ and $D$ along the batch dimension and then split both tensors into a training set consisting of 80% of the data and a testing set with the remaining 20%.\n", - "\n", - "**Hint** for the shuffling `torch.randperm` may be useful." + "### TODO: Create the neural network with 3 hidden layers and 25 neurons each.\n", + "model = ..." ] }, { @@ -156,26 +86,11 @@ "metadata": {}, "outputs": [], "source": [ - "### TODO: Permute data of u, D and split them into two sets (training and testing)\n", - "\n", - "# permute ....\n", - "permutation = torch.randperm(len(D_tensor))\n", - "u_tensor = u_tensor[permutation]\n", - "D_tensor = D_tensor[permutation]\n", + "### TODO: Define condition for the ODE:\n", + "def ode_residual():\n", + " pass\n", "\n", - "# Then split\n", - "u_tensor_train = u_tensor[:10000]\n", - "D_tensor_train = D_tensor[:10000]\n", - "u_tensor_test = u_tensor[10000:]\n", - "D_tensor_test = D_tensor[10000:]" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we start with the TorchPhysics part" + "ode_condition = ..." ] }, { @@ -184,17 +99,11 @@ "metadata": {}, "outputs": [], "source": [ - "# Spaces \n", - "T = tp.spaces.R1('t') # input variable\n", - "U = tp.spaces.R1('u') # output variable\n", - "D = tp.spaces.R1('D') # function output space name\n", + "### Other conditions are also like before:\n", + "def position_residual(u):\n", + " return u - H\n", "\n", - "# Domain\n", - "int_x = tp.domains.Interval(T, t_min, t_max)\n", - "\n", - "# Space that collects the Branch functions\n", - "Fn_space = tp.spaces.FunctionSpace(int_x, D)\n", - "discretization_sampler = tp.samplers.DataSampler(tp.spaces.Points(t_tensor[::2], T))" + "initial_position_condition = tp.conditions.PINNCondition(model, initial_sampler, position_residual)" ] }, { @@ -203,220 +112,56 @@ "metadata": {}, "outputs": [], "source": [ - "output_neurons = 25\n", - "branch_net = tp.models.FCBranchNet(Fn_space, discretization_sampler, (30,30,30))\n", - "trunk_net = tp.models.FCTrunkNet(T, (30,30,30))\n", - "deepOnet = tp.models.DeepONet(trunk_net, branch_net, U, output_neurons)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "branch_batch_size = len(u_tensor_train)\n", - "trunk_batch_size = len(t_tensor)\n", - "dataloader = tp.utils.DeepONetDataLoader(D_tensor_train, t_tensor, u_tensor_train, D, T, U,\n", - " branch_batch_size, trunk_batch_size)" + "def velocity_residual(u, t):\n", + " return tp.utils.grad(u, t)\n", + "\n", + "initial_velocity_condition = tp.conditions.PINNCondition(model, initial_sampler, velocity_residual)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "data_condition = tp.conditions.DeepONetDataCondition(deepOnet, dataloader, 2, root=2)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True, used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 6.3 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "6.3 K Trainable params\n", - "0 Non-trainable params\n", - "6.3 K Total params\n", - "0.025 Total estimated model params size (MB)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "be785d8d4f4c40518e8c6063cedbaf07", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "695ac09798aa4c5ca29d01b3c0759683", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ + "### Syntax for the training is already implemented:\n", "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate) \n", - "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", - "\n", + "solver = tp.solver.Solver([ode_condition, initial_position_condition, initial_velocity_condition],\n", + " optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " num_sanity_val_steps=0,\n", + "trainer = pl.Trainer(gpus=1, # or None on a CPU\n", " benchmark=True,\n", " max_steps=train_iterations,\n", - " logger=False\n", - " )\n", + " logger=False)\n", "\n", "trainer.fit(solver)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Max. absolute error on test set is: 1.6479072570800781\n", - "Relative error is: 0.032958145141601565\n" - ] - } - ], - "source": [ - "# Check error on test set:\n", - "u_model = deepOnet(tp.spaces.Points(t_tensor, T), D_tensor_test).as_tensor\n", - "error = torch.abs(u_model - u_tensor_test)\n", - "print(\"Max. absolute error on test set is:\", torch.max(error).item())\n", - "print(\"Relative error is:\", torch.max(error).item() / 50.0)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# Plot a solution from the test set:\n", - "plot_idx = 786\n", - "\n", - "u_model = deepOnet(tp.spaces.Points(t_tensor, T), D_tensor_test[plot_idx]).as_tensor[0]\n", - "ref_solution = u_tensor_test[plot_idx]\n", + "### Here, plot the solution:\n", + "import matplotlib.pyplot as plt\n", "\n", - "plt.figure(0, figsize=(14, 4))\n", - "plt.subplot(1, 3, 1)\n", - "plt.plot(t_tensor[::2], D_tensor_test[plot_idx])\n", - "plt.title(\"D(t)\")\n", - "plt.xlabel(\"t\")\n", - "plt.grid()\n", - "plt.subplot(1, 3, 2)\n", - "plt.plot(t_tensor, u_model.detach())\n", - "plt.plot(t_tensor, ref_solution)\n", + "plot_sampler = tp.samplers.PlotSampler(int_t, 200)\n", + "fig = tp.utils.plot(model, lambda u: u, plot_sampler)\n", "plt.title(\"Solution\")\n", - "plt.legend([\"DeepONet\", \"Real Solution\"])\n", - "plt.xlabel(\"t\")\n", - "plt.grid()\n", - "plt.subplot(1, 3, 3)\n", - "plt.plot(t_tensor, torch.abs(ref_solution - u_model.detach()))\n", - "plt.title(\"Absolute Difference\")\n", - "plt.xlabel(\"t\")\n", - "plt.grid()\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Now a test for constant values of D:\n", - "test_D = 0.05\n", - "\n", - "def analytic_solution(t, D):\n", - " return 1/D * (-torch.log((1+torch.exp(-2*torch.sqrt(D*g)*t))/2) - torch.sqrt(D*g)*t) + H\n", "\n", - "# Evaluate model:\n", - "u_model = deepOnet(tp.spaces.Points(t_tensor, T), lambda t: test_D*torch.ones_like(t)).as_tensor[0]\n", - "ref_solution = analytic_solution(t_tensor, torch.tensor(test_D))\n", - " \n", - "# Plot\n", - "plt.figure(0, figsize=(14, 4))\n", - "plt.subplot(1, 3, 1)\n", - "plt.plot(t_tensor, u_model.detach())\n", - "plt.title(\"Neural Network\")\n", - "plt.xlabel(\"t\")\n", - "plt.grid()\n", - "plt.subplot(1, 3, 2)\n", - "plt.plot(t_tensor, ref_solution)\n", - "plt.title(\"Reference Solution\")\n", - "plt.xlabel(\"t\")\n", - "plt.grid()\n", - "plt.subplot(1, 3, 3)\n", - "plt.plot(t_tensor, torch.abs(ref_solution - u_model.detach()))\n", - "plt.title(\"Absolute Difference\")\n", - "plt.xlabel(\"t\")\n", - "plt.grid()\n", - "plt.tight_layout()" + "# Solution for comparision with backward euler:\n", + "t = torch.linspace(t_min, t_max, 200)\n", + "dt = t[1] - t[0]\n", + "D_fn = D(t)\n", + "u, v = torch.zeros_like(t), torch.zeros_like(t)\n", + "u[0] = H\n", + "for i in range(len(t)-1):\n", + " v[i+1] = 1/(2*dt*D_fn[i+1]) - torch.sqrt(1/(2*dt*D_fn[i+1])**2 - (v[i] - dt*g)/(dt*D_fn[i+1]))\n", + " u[i+1] = u[i] + dt * v[i+1]\n", + "\n", + "plt.plot(t, u, linestyle=\"--\")\n", + "plt.legend([\"Neural Network\", \"Backward Euler\"])" ] } ], diff --git a/examples/workshop/Exercise3_2.ipynb b/examples/workshop/Exercise3_2.ipynb new file mode 100644 index 00000000..05f44e89 --- /dev/null +++ b/examples/workshop/Exercise3_2.ipynb @@ -0,0 +1,672 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 3\n", + "\n", + "#### 3.2 Learning the Solution Operator\n", + "Use TorchPhysics and DeepONets to solve the ODE with time dependent $D(t)$:\n", + "\n", + "\\begin{align*}\n", + " \\partial_t^2 u(t) &= D(t)(\\partial_t u(t))^2 - g \\\\\n", + " u(0) &= H \\\\\n", + " \\partial_t u(0) &= 0\n", + "\\end{align*}\n", + "\n", + "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell. Since the installation can take around 2 minutes and has to be redone if you switch to the GPU later." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install torchaudio==0.13.0\n", + "!pip install torchphysics" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl\n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 3.0\n", + "g, H = 9.81, 50.0\n", + "D_min, D_max = 0.005, 5.0\n", + "# Size of the data set\n", + "data_batch = 12000\n", + "\n", + "# Number of time points for discretization of D and training\n", + "N_t = 60\n", + "\n", + "# Training parameters\n", + "train_iterations = 10000\n", + "learning_rate = 5.e-4" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "### Function that uses backward Euler to create the dataset (you dont have to understand this cell):\n", + "def data_create_fn(N_t, data_batch, start_height):\n", + " # Time grid (Trunk input)\n", + " t = torch.linspace(0, 3.0, 60)\n", + " dt = t[1] - t[0]\n", + " # Tensors for Branch input and expected output\n", + " D_fn = torch.zeros((data_batch, len(t), 1))\n", + " u = torch.zeros((data_batch, len(t), 1))\n", + " v = torch.zeros((data_batch, len(t), 1))\n", + " \n", + " # Create different fuction types for D_fn:\n", + " # First batch are step functions:\n", + " ind = int(data_batch / 3.0)\n", + " random_steps = D_min + (D_max - D_min) * torch.rand((ind, 6, 1))\n", + " D_fn[:ind, :] = random_steps.repeat_interleave(int(N_t/6), dim=1)\n", + " # Second batch are sinus functions:\n", + " random_fre_amp = D_min + (D_max - D_min) * torch.rand((ind, 1, 2))\n", + " random_fre_amp = random_fre_amp.repeat_interleave(N_t, dim=1)\n", + " sin_fn = random_fre_amp[:, :, 1]/2.0 * (D_min + 1 + torch.sin(random_fre_amp[:, :, 0] * t))\n", + " D_fn[ind:2*ind, :] = sin_fn.unsqueeze(-1)\n", + " # Last batch is exp functions:\n", + " missing_idx = data_batch - 2*ind\n", + " random_start_sloope = (D_max - D_min) * torch.rand((missing_idx, 1, 2))\n", + " random_start_sloope = random_start_sloope.repeat_interleave(N_t, dim=1)\n", + " exp_fn = D_min + random_start_sloope[:, :, 1] * torch.exp(-random_start_sloope[:, :, 0] * t)\n", + " D_fn[2*ind:, :] = exp_fn.unsqueeze(-1)\n", + " # flip some exp functions around t=1.5:\n", + " D_fn[int(2*ind + missing_idx/2.0):, :] = torch.flip(D_fn[int(2*ind + missing_idx/2.0):, :, :], dims=(1,))\n", + " \n", + " # Do time stepping to compute solution\n", + " u[:, 0] = start_height\n", + " for i in range(len(t)-1):\n", + " v[:, i+1] = 1/(2*dt*D_fn[:, i+1]) - torch.sqrt(1/(2*dt*D_fn[:, i+1])**2 - (v[:, i] - dt*g)/(dt*D_fn[:, i+1]))\n", + " u[:, i+1] = u[:, i] + dt * v[:, i+1]\n", + "\n", + " return t.reshape(-1, 1), u, D_fn[:, ::2, :]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Here we create the data\n", + "t_tensor, u_tensor, D_tensor = data_create_fn(N_t, data_batch, H)\n", + "\n", + "### Show an example plot\n", + "import matplotlib.pyplot as plt\n", + "plt.figure(figsize=(16, 4))\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(t_tensor[::2], D_tensor[0])\n", + "plt.plot(t_tensor[::2], D_tensor[4000])\n", + "plt.plot(t_tensor[::2], D_tensor[8000])\n", + "plt.ylabel(\"D\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(t_tensor, u_tensor[0])\n", + "plt.plot(t_tensor, u_tensor[4000])\n", + "plt.plot(t_tensor, u_tensor[8000])\n", + "plt.ylabel(\"u\")\n", + "plt.xlabel(\"t\")\n", + "plt.title(\"Solution for corresponding D\")\n", + "plt.grid()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### a) Shuffle and Split Data \n", + "The above data is created in ordered way (e.g. first 4000 entries belong to step functions). Randomly permute the tensors of $u$ and $D$ along the batch dimension and then split both tensors into a training set consisting of 80% of the data and a testing set with the remaining 20%.\n", + "\n", + "**Hint**: for the shuffling `torch.randperm` may be useful." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Permute data of u, D along the batch dimension and split them into two sets (training and testing)\n", + "\n", + "# Permute \n", + "\n", + "\n", + "# Then split\n", + "u_tensor_train = ...\n", + "D_tensor_train = ...\n", + "u_tensor_test = ...\n", + "D_tensor_test = ..." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we start with the TorchPhysics part" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### b) Define Spaces, the Domain and the Sampler for discretization\n", + "The spaces and domain are similiar to before. One also needs an output space for the functions $D(t)$ and then create a \n", + "function space that defines that functions from $[0, 3.0] \\to \\R$ are considered.\n", + "\n", + "Later the BranchNet needs a sampler for discretization of the input functions (even if our training set is already discrete, in the case one later evaluates with a non discrete function).\n", + "The sampler should return **every second value** of the time points in `t_tensor`. For this the `tp.samplers.DataSampler` can be used. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Spaces \n", + "\n", + "# Domain\n", + "\n", + "# Space that collects the Branch functions\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### c) Construct the DeepONet\n", + "Build a DeepONet consisting of a fully connected TrunkNet and BranchNet. Check the `TorchPhysics` [documentation](https://torchphysics.readthedocs.io/en/latest/api/torchphysics.models.deeponet.html), to see how this has to implemented. \n", + "\n", + "Both (TrunkNet and BranchNet) should have 3 hidden layers with 25 neurons each. The output of both networks should be 30 neurons." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Build the DeepONet\n", + "\n", + "\n", + "DeepONet = ..." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "### Create data loader to fit DeepONet to the given data.\n", + "branch_batch_size = len(u_tensor_train)\n", + "trunk_batch_size = len(t_tensor)\n", + "dataloader = tp.utils.DeepONetDataLoader(D_tensor_train, t_tensor, u_tensor_train, D, T, U,\n", + " branch_batch_size, trunk_batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "data_condition = tp.conditions.DeepONetDataCondition(DeepONet, dataloader, 2, root=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 5.0 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "5.0 K Trainable params\n", + "0 Non-trainable params\n", + "5.0 K Total params\n", + "0.020 Total estimated model params size (MB)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dda967d70d5848a8bf3226e1857d7651", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "50dafed2573f4f36bd3936b249a77fe3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### Start training\n", + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate) \n", + "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", + "\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=train_iterations,\n", + " logger=False\n", + " )\n", + "\n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max. absolute error on test set is: 1.4154281616210938\n", + "Relative error is: 0.028308563232421875\n" + ] + } + ], + "source": [ + "### Check error on test set:\n", + "u_model = DeepONet(tp.spaces.Points(t_tensor, T), D_tensor_test).as_tensor\n", + "error = torch.abs(u_model - u_tensor_test)\n", + "print(\"Max. absolute error on test set is:\", torch.max(error).item())\n", + "print(\"Relative error is:\", torch.max(error).item() / 50.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Plot a solution from the test set:\n", + "plot_idx = 321 # <- can you change!\n", + "\n", + "u_model = DeepONet(tp.spaces.Points(t_tensor, T), D_tensor_test[plot_idx]).as_tensor[0]\n", + "ref_solution = u_tensor_test[plot_idx]\n", + "\n", + "plt.figure(0, figsize=(14, 4))\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(t_tensor[::2], D_tensor_test[plot_idx])\n", + "plt.title(\"D(t)\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(t_tensor, u_model.detach())\n", + "plt.plot(t_tensor, ref_solution)\n", + "plt.title(\"Solution\")\n", + "plt.legend([\"DeepONet\", \"Real Solution\"])\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(t_tensor, torch.abs(ref_solution - u_model.detach()))\n", + "plt.title(\"Absolute Difference\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Now a test for constant values of D:\n", + "test_D = 0.05\n", + "\n", + "def analytic_solution(t, D):\n", + " return 1/D * (-torch.log((1+torch.exp(-2*torch.sqrt(D*g)*t))/2) - torch.sqrt(D*g)*t) + H\n", + "\n", + "# Evaluate model:\n", + "u_model = DeepONet(tp.spaces.Points(t_tensor, T), lambda t: test_D*torch.ones_like(t)).as_tensor[0]\n", + "ref_solution = analytic_solution(t_tensor, torch.tensor(test_D))\n", + " \n", + "# Plot\n", + "plt.figure(0, figsize=(14, 4))\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(t_tensor, u_model.detach())\n", + "plt.title(\"Neural Network\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(t_tensor, ref_solution)\n", + "plt.title(\"Reference Solution\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(t_tensor, torch.abs(ref_solution - u_model.detach()))\n", + "plt.title(\"Absolute Difference\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Lastly, we can also evaluate the network with a custom non discrete function:\n", + "def test_fn(t):\n", + " return 1.1 + torch.sin(3.5*t)\n", + "\n", + "u_model = DeepONet(tp.spaces.Points(t_tensor, T), test_fn).as_tensor[0]\n", + "plt.plot(t_tensor, u_model.detach())\n", + "plt.title(\"Neural Network\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instead of using the DeepONet architecture, we could also try to learn the solution operator with a simple \n", + "fully connected neural network. E.g have network with input $(t, D(t_1), \\dots, D(t_N))$ and output $u(t; D)$.\n", + "\n", + "This is implemented in the following cell and a comparision is shown in the last cell." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 5.0 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "5.0 K Trainable params\n", + "0 Non-trainable params\n", + "5.0 K Total params\n", + "0.020 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f3abce76c8ae4450b360e831edf1f934", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d29536bbb08d4559a53c5fe7e7b5ecd4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4bf657d088a44fb696e06f50b56ef1f5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### Compare with simple FCN:\n", + "D_vec = tp.spaces.Rn('D', 30)\n", + "\n", + "fcn_model = tp.models.FCN(T*D_vec, U, hidden=(42, 42, 42))\n", + "\n", + "# permute data and create condition:\n", + "complete_data = torch.zeros((len(D_tensor_train), 60, 31))\n", + "complete_data[:, :, :1] = t_tensor\n", + "complete_data[:, :, 1:] = D_tensor_train.squeeze(-1).unsqueeze(1)\n", + "\n", + "in_data_points = tp.spaces.Points(complete_data, T*D_vec)\n", + "out_data_points = tp.spaces.Points(u_tensor_train, U)\n", + "\n", + "data_loader = tp.utils.PointsDataLoader((in_data_points, out_data_points), batch_size=len(in_data_points))\n", + "data_condition_fcn = tp.conditions.DataCondition(module=fcn_model,\n", + " dataloader=data_loader,\n", + " norm=2, use_full_dataset=True)\n", + "\n", + "# start training\n", + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate)\n", + "solver = tp.solver.Solver(train_conditions=[data_condition_fcn], optimizer_setting=optim)\n", + "\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " max_steps=train_iterations,\n", + " logger=False,\n", + " benchmark=True)\n", + " \n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Plot a solution from the test set:\n", + "plot_idx = 921 # <- can you change!\n", + "\n", + "fcn_input = torch.zeros((1, 60, 31))\n", + "fcn_input[:, :, :1] = t_tensor\n", + "fcn_input[:, :, 1:] = D_tensor_test[plot_idx].squeeze(-1).unsqueeze(0)\n", + "\n", + "fcn_model_out = fcn_model(tp.spaces.Points(fcn_input, T*D_vec)).as_tensor.detach()[0]\n", + "u_model = DeepONet(tp.spaces.Points(t_tensor, T), D_tensor_test[plot_idx]).as_tensor[0]\n", + "ref_solution = u_tensor_test[plot_idx]\n", + "\n", + "plt.figure(0, figsize=(14, 4))\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(t_tensor[::2], complete_data[plot_idx, 0, 1:])\n", + "plt.title(\"D(t)\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(t_tensor, u_model.detach())\n", + "plt.plot(t_tensor, fcn_model_out, linestyle=\"--\")\n", + "plt.plot(t_tensor, ref_solution)\n", + "plt.title(\"Solution\")\n", + "plt.legend([\"DeepONet\", \"FCN\", \"Real Solution\"])\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(t_tensor, torch.abs(fcn_model_out- u_model.detach()))\n", + "plt.title(\"Absolute Difference between FCN and DeepONet\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/Sol2_2.ipynb b/examples/workshop/Sol2_2.ipynb index e75a7a8d..79f172ac 100644 --- a/examples/workshop/Sol2_2.ipynb +++ b/examples/workshop/Sol2_2.ipynb @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -76,7 +76,7 @@ "plt.grid()\n", "plt.title(\"temperature of the heater over time\")\n", "\n", - "# Number of time points \n", + "# Number of training points \n", "N_pde = 15000\n", "N_initial = 5000\n", "N_boundary = 5000\n", @@ -98,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -120,12 +120,12 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -147,7 +147,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -157,7 +157,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -171,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -184,7 +184,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -232,7 +232,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "815b926a58934870815ce08270679b62", + "model_id": "2756b6d6f99741a18a2100c1f2848283", "version_major": 2, "version_minor": 0 }, @@ -243,20 +243,10 @@ "metadata": {}, "output_type": "display_data" }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n" - ] - }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3e6fb399bca74853bdef428c1ab1d746", + "model_id": "3560204f19f246ba9a392fdf3f923e71", "version_major": 2, "version_minor": 0 }, @@ -270,7 +260,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0591ca91a014434389d22e47d5987ab0", + "model_id": "6ed05b29c99e4e11b2f948fa31886b28", "version_major": 2, "version_minor": 0 }, @@ -291,20 +281,19 @@ "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", " max_steps=train_iterations, # number of training steps\n", " logger=False,\n", - " benchmark=True, \n", - " enable_checkpointing=False)\n", + " benchmark=True)\n", "\n", "trainer.fit(solver) # run the training loop" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 49, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -326,7 +315,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -356,6 +345,50 @@ "anim.save('heat-eq.gif')\n", "# On Google colab you have at the left side a tab with a folder. There you should find the gif and watch it." ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# !wget https://github.com/TomF98/torchphysics/raw/main/examples/workshop/FEMData/Data2_2/time_points.pt\n", + "# !wget https://github.com/TomF98/torchphysics/raw/main/examples/workshop/FEMData/Data2_2/space_coords.pt\n", + "# !wget https://github.com/TomF98/torchphysics/raw/main/examples/workshop/FEMData/Data2_2/temperature.pt" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([41, 546, 1])\n", + "Max. absolute error between FE and PINN: tensor(7.2122, grad_fn=)\n", + "Relative error is: tensor(0.1803, grad_fn=)\n" + ] + } + ], + "source": [ + "# Lastly, we can compare the results with an finite element solution:\n", + "import numpy as np\n", + "fe_time = torch.load(\"time_points.pt\")\n", + "fe_space = torch.load(\"space_coords.pt\")\n", + "fe_temperature = torch.load(\"temperature.pt\")\n", + "\n", + "in_data = torch.zeros((len(fe_time), len(fe_space), 3))\n", + "in_data[:, :, :2] = fe_space\n", + "in_data[:, :, 2] = fe_time.repeat(1, len(fe_space))\n", + "\n", + "model_out = model(tp.spaces.Points(in_data, X*T))\n", + "print(model_out.as_tensor.shape)\n", + "error = torch.abs(model_out.as_tensor - fe_temperature)\n", + "print(\"Max. absolute error between FE and PINN:\", torch.max(error))\n", + "print(\"Relative error is:\", torch.max(error)/torch.max(fe_temperature))" + ] } ], "metadata": { diff --git a/examples/workshop/Sol2_3.ipynb b/examples/workshop/Sol2_3.ipynb new file mode 100644 index 00000000..36197e55 --- /dev/null +++ b/examples/workshop/Sol2_3.ipynb @@ -0,0 +1,472 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 2\n", + "\n", + "#### 2.3 Solving an inverse Problem with TorchPhysics\n", + "We consider now the wave equation\n", + "\n", + "\\begin{align*}\n", + " \\partial_t^2 u &= c \\, \\partial_x^2 u, &&\\text{ in } I_x \\times I_t, \\\\\n", + " u &= 0 , &&\\text{ on } \\partial I_x \\times I_t, \\\\\n", + " \\partial_t u &= 0 , &&\\text{ on } \\partial I_x \\times I_t, \\\\\n", + " u(\\cdot, 0) &= \\sin(x) , &&\\text{ in } I_x,\n", + "\\end{align*}\n", + "\n", + "with $I_x = [0, 2\\pi]$ and $I_t = [0, 20]$. We are given a noisy dataset $\\{(u_i, x_i, t_i)\\}_{i=1}^N$ and aim to determine the corresponding value of $c$." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torchphysics as tp\n", + "import pytorch_lightning as pl\n", + "import torch\n", + "import math\n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 20.0\n", + "width = 2 * math.pi \n", + "\n", + "# Number of training points \n", + "N_pde = 20000\n", + "\n", + "# Training parameters\n", + "train_iterations = 5000\n", + "learning_rate = 1.e-3" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Implement the spaces\n", + "X = tp.spaces.R1('x')\n", + "T = tp.spaces.R1('t')\n", + "U = tp.spaces.R1('u')\n", + "C = tp.spaces.R1('c')\n", + "\n", + "### TODO: Define the domain omega and time interval \n", + "I_x = tp.domains.Interval(space=X, lower_bound=0.0, upper_bound=width)\n", + "I_t = tp.domains.Interval(space=T, lower_bound=t_min, upper_bound=t_max)\n", + "\n", + "### TODO: Create sampler for the PDE condition inside I_x x I_t\n", + "pde_sampler = tp.samplers.RandomUniformSampler(domain=I_x * I_t, n_points=N_pde)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Create the neural networks for the solution u and the learnable parameter c.\n", + "### The model of u should contain 3 hidden layers with 50 neurons each and should have\n", + "### X*T as an input space (order is important for the following cells).\n", + "### For the parameter c use `tp.models.Parameter`\n", + "model_u = tp.models.FCN(input_space=X*T, output_space=U, hidden = (50,50,50))\n", + "param_C = tp.models.Parameter(init=1.0, space=C)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the PDE:\n", + "def pde_residual(c, u, t, x):\n", + " return tp.utils.laplacian(u, t) - c * tp.utils.laplacian(u, x)\n", + "\n", + "pde_condition = tp.conditions.PINNCondition(model_u, pde_sampler, pde_residual, parameter=param_C)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Here, we load the data. First download it from GitHub and then read it with\n", + "### PyTorch. `in_data` contains combinations of X*T points and 'out_data' the \n", + "### coressponding ampltidue of the wave.\n", + "\n", + "!wget https://github.com/TomF98/torchphysics/raw/main/examples/workshop/FEMData/Data2_3/time_points.pt\n", + "!wget https://github.com/TomF98/torchphysics/raw/main/examples/workshop/FEMData/Data2_3/space_coords.pt\n", + "!wget https://github.com/TomF98/torchphysics/raw/main/examples/workshop/FEMData/Data2_3/wave_data.pt" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data has the shape:\n", + "torch.Size([13065, 2]) torch.Size([13065, 1])\n" + ] + } + ], + "source": [ + "fe_time = torch.load(\"time_points.pt\")\n", + "fe_space = torch.load(\"space_coords.pt\")\n", + "out_data = torch.load(\"wave_data.pt\")\n", + "\n", + "in_data = torch.zeros((len(fe_time), len(fe_space), 2))\n", + "in_data[:, :, :1] = fe_space\n", + "in_data[:, :, 1] = fe_time\n", + "\n", + "in_data = in_data.reshape(-1, 2)\n", + "\n", + "print(\"Data has the shape:\")\n", + "print(in_data.shape, out_data.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Randomly shuffle the data from the previous cell, add 1% of articfical noise to the `out_data`\n", + "### and then select for the training only the first half of the data batch.\n", + "### Hint: for the random shuffle `torch.randperm` is useful and for constructing noise \n", + "### use: `0.01 * torch.randn_like(out_data) * out_data`\n", + "permutation = torch.randperm(len(in_data))\n", + "in_data = in_data[permutation]\n", + "out_data = out_data[permutation]\n", + "out_data += 0.01 * torch.randn_like(out_data) * torch.max(out_data)\n", + "\n", + "in_data = in_data[:int(len(in_data)/2.0)]\n", + "out_data = out_data[:int(len(out_data)/2.0)]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Transform the data from the previous cell into `tp.spaces.Points` objects, to\n", + "### assign them a space and enable TorchPhysics to work with them:\n", + "in_data_points = tp.spaces.Points(in_data, X*T)\n", + "out_data_points = tp.spaces.Points(out_data, U)\n", + "\n", + "### Here we create a DataLoader, that passes the above data to the conditions and\n", + "### also controls the batch size, the device (CPU or GPU) and more...\n", + "### And also the condition, that fits the given model to the data\n", + "data_loader = tp.utils.PointsDataLoader((in_data_points, out_data_points), batch_size=len(in_data))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Complete the data condtion given below, by inserting the missing \n", + "### keywords. The `tp.conditions.DataCondition` fits the given model to the \n", + "### provided data of the dataloader.\n", + "data_condition = tp.conditions.DataCondition(module=model_u,\n", + " dataloader=data_loader,\n", + " norm=2, use_full_dataset=True,\n", + " weight=100) " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 5.3 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "5.3 K Trainable params\n", + "0 Non-trainable params\n", + "5.3 K Total params\n", + "0.021 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5ea92ad033bf4fb49d1cebca013bddc0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3620b234128f4d7ea4bb872099f1c7e8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6b653c61be4643faa4861dc11eb28b26", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate)\n", + "solver = tp.solver.Solver(train_conditions=[data_condition, pde_condition], optimizer_setting=optim)\n", + "\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " max_steps=train_iterations,\n", + " logger=False,\n", + " benchmark=True)\n", + " \n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 5.3 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "5.3 K Trainable params\n", + "0 Non-trainable params\n", + "5.3 K Total params\n", + "0.021 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "95040296d55e44c196876eda625903bf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "029ef956af674ec1b71d31490695d1dd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bc42fdba7a1949cb811d91cb040df1f1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.LBFGS, lr=0.5, optimizer_args={'max_iter': 2})\n", + "pde_condition.sampler = pde_condition.sampler.make_static()\n", + "solver = tp.solver.Solver([pde_condition, data_condition], optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " max_steps=2000,\n", + " logger=False,\n", + " benchmark=True)\n", + " \n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original value of c is: 0.742\n", + "With PINNs we computed the value: 0.7323731780052185\n", + "Relative difference is: 0.01297415363178098\n" + ] + } + ], + "source": [ + "print(\"Correct value of c is: 0.742\")\n", + "print(\"With PINNs we computed the value:\", param_C.as_tensor.item())\n", + "print(\"Relative difference is:\", abs(0.742 - param_C.as_tensor.item()) / 0.742)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/torch/functional.py:478: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:2895.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n", + "/home/tomfre/Desktop/torchphysics/src/torchphysics/problem/domains/domain2D/parallelogram.py:134: UserWarning: The use of `x.T` on tensors of dimension other than 2 to reverse their shape is deprecated and it will throw an error in a future release. Consider `x.mT` to transpose batches of matricesor `x.permute(*torch.arange(x.ndim - 1, -1, -1))` to reverse the dimensions of a tensor. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:2985.)\n", + " bary_coords = torch.stack(torch.meshgrid((x, y))).T.reshape(-1, 2)\n", + "/home/tomfre/Desktop/torchphysics/src/torchphysics/utils/plotting/plot_functions.py:416: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:204.)\n", + " embed_point = Points(torch.tensor([center]), domain.space)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### We can also plot the solution that we learned\n", + "plot_domain = tp.domains.Parallelogram(X*T, [0, 0], [width, 0], [0, t_max])\n", + "plot_sampler = tp.samplers.PlotSampler(plot_domain, 1000)\n", + "fig = tp.utils.plot(model_u, lambda u: u, plot_sampler, plot_type=\"contour_surface\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "MovieWriter ffmpeg unavailable; using Pillow instead.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Or an animation:\n", + "anim_sampler = tp.samplers.AnimationSampler(I_x, I_t, 200, n_points=250)\n", + "fig, anim = tp.utils.animate(model_u, lambda u: u, anim_sampler, ani_speed=40)\n", + "anim.save('wave-eq.gif')\n", + "# On Google colab you have at the left side a tab with a folder. There you should find the gif and can watch it." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/Sol3_1.ipynb b/examples/workshop/Sol3_1.ipynb new file mode 100644 index 00000000..1a49328b --- /dev/null +++ b/examples/workshop/Sol3_1.ipynb @@ -0,0 +1,298 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 2\n", + "\n", + "#### 2.1 ODE with time dependent Parameter\n", + "Use TorchPhysics to solve the ODE for falling with a parachute:\n", + "\\begin{align*}\n", + " \\partial_t^2 u(t) &= D(t)(\\partial_t u(t))^2 - g \\\\\n", + " u(0) &= H \\\\\n", + " \\partial_t u(0) &= 0\n", + "\\end{align*}\n", + "Where now $D: \\R \\to \\R$ with $ D(t) = 2.0\\cdot(1.0 + \\sin(4\\cdot t))$." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#!pip install torchaudio==0.13.0\n", + "#!pip install torchphysics\n", + "\n", + "# This will give some error messages, because some package on Google colab use newer versions than we need.\n", + "# You can ignore the errors, since we dont need the mentioned packages.\n", + "# Also, TorchPhysics will only be installed for this session, once you close the notebook it will\n", + "# be automatically deleted and everything resets to default." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl\n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 3.0\n", + "\n", + "### TODO: implement the function of D.\n", + "def D(t):\n", + " return 2.0 * (1.0 + torch.sin(4*t))\n", + "g, H = 9.81, 50.0\n", + "\n", + "# number of time points \n", + "N_t = 500\n", + "N_initial = 1\n", + "\n", + "train_iterations = 10000\n", + "learning_rate = 1.e-3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "### Spaces, Domains and Sampler like yesterday:\n", + "T = tp.spaces.R1('t')\n", + "U = tp.spaces.R1('u')\n", + " \n", + "int_t = tp.domains.Interval(T, t_min, t_max)\n", + "\n", + "ode_sampler = tp.samplers.RandomUniformSampler(int_t, n_points=N_t)\n", + "initial_sampler = tp.samplers.RandomUniformSampler(int_t.boundary_left, n_points=N_initial)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Create the neural network with 3 hidden layers and 25 neurons each.\n", + "model = tp.models.FCN(T, U, hidden=(25, 25, 25))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Define condition for the ODE:\n", + "def ode_residual(u, t):\n", + " u_t = tp.utils.grad(u, t)\n", + " u_tt = tp.utils.grad(u_t, t)\n", + " return u_tt - D(t)*u_t**2 + g\n", + "\n", + "ode_condition = tp.conditions.PINNCondition(model, ode_sampler, ode_residual)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "### Other conditions are also like before:\n", + "def position_residual(u):\n", + " return u - H\n", + "\n", + "initial_position_condition = tp.conditions.PINNCondition(model, initial_sampler, position_residual)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def velocity_residual(u, t):\n", + " return tp.utils.grad(u, t)\n", + "\n", + "initial_velocity_condition = tp.conditions.PINNCondition(model, initial_sampler, velocity_residual)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 901 \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "901 Trainable params\n", + "0 Non-trainable params\n", + "901 Total params\n", + "0.004 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "22d23ce2b26945eb9065a00c10c47697", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c1b52d1225f043dd9d6d8b3fb330560e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f7bcdcf232ac4409aea28ab55aae55aa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### Syntax for the training is already implemented:\n", + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate) \n", + "solver = tp.solver.Solver([ode_condition, initial_position_condition, initial_velocity_condition],\n", + " optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(gpus=1, # or None on a CPU\n", + " benchmark=True,\n", + " max_steps=train_iterations,\n", + " logger=False, \n", + " )\n", + "\n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAEWCAYAAAB/tMx4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA3NUlEQVR4nO3deZyN5fvA8c81Z/aVMQwa+5JswyyWNBhKZWtRiIgWqZQSvimlb6X9m9JCSfYMiRYhxcgSYiTZidRIlrEOBjNz//6Yw28wzJkzZ+Ysc71fr3k5z3qua5665j73eZ77FmMMSiml3I+XswNQSillHy3gSinlprSAK6WUm9ICrpRSbkoLuFJKuSkt4Eop5aa0gCuPJyJVRcSIiLedx/cUkYWOjkupwtICrtyKiNwgIj+LyDEROSwiK0Qk3oHnv6zYG2OmGWPaOeo9lHIUu1okSjmDiIQCc4FHgJmAL5AAnHFmXEo5i7bAlTupDWCMmW6MyTLGnDbGLDTGbBARLxEZLiJ7ROSAiEwWkbC8TiIif4rIjbmWXxSRqdbFpdZ/j4pIuog0F5E+IrI81/7Xi8ga66eANSJyfa5tS0TkZesngxMislBEIhz/q1BKC7hyL9uBLBGZJCK3ikjpXNv6WH8SgepAMPCBHe/R0vpvKWNMsDFmZe6NIhIOfAeMBsoA7wDfiUiZXLv1APoC5cj5lDDYjjiUypcWcOU2jDHHgRsAA4wDDorINyISCfQE3jHG7DLGpAPDgO72fnF5FR2AHcaYKcaYTGPMdGAr0CnXPhOMMduNMafJ6epp5OAYlAK0gCs3Y4zZYozpY4yJAuoDFYF3rf/uybXrHnK+44l0cAiXvs/597om1/K/uV6fIufTgFIOpwVcuS1jzFZgIjmF/B+gSq7NlYFMYH8eh54EAnMtl8992nze9tL3Of9ee/OPWCnH0gKu3IaI1BGRp0UkyrpcCbgHWAVMB54SkWoiEgy8CswwxmTmcar15HSv+IhIHHBXrm0HgWxy+tHzMg+oLSI9RMRbRLoBdcm5O0apYqW3ESp3cgJoCgwSkVLAUXIK5xAgnZzujaWAP/A98PgVzvM8OQX/CPAT8DkQDmCMOSUiI4EVIuID3JL7QGNMmoh0BN4DxgA7gY7GmEMOy1IpG4lO6KCUUu5Ju1CUUspNaQFXSik3pQVcKaXclBZwpZRyU8V6F0pERISpWrWqXceePHmSoKAgxwbkJJ6Si6fkAZqLq/KUXAqbR0pKyiFjTNlL1xdrAa9atSpr166169glS5bQunVrxwbkJJ6Si6fkAZqLq/KUXAqbh4hc+vQvoF0oSinltrSAK6WUm9ICrpRSbkofpVfKQ5w7d47U1FTCwsLYsmWLs8NxCE/JxdY8/P39iYqKwsfHx6bzagFXykOkpqYSEhJCmTJlCA0NdXY4DnHixAlCQkKcHUah2ZKHMYa0tDRSU1OpVq2aTee1qQvFOgXV7yKyXkTWWteFi8gPIrLD+m/p/M6jlCo6GRkZlClTBhFxdijKDiJCmTJlyMjIsPmYgvSBJxpjGhlj4qzLzwCLjDG1gEXWZaWUE2nxdm8FvX6F6UK5DWhtfT0JWAL8pxDnu6I5v6Yiv37J8r0rwDcEr+AyBJSrRqkKNalQtgz+PpaieFullHJpNg0nKyK7yRk72QAfG2M+EZGjxphS1u0CHDm/fMmx/YB+AJGRkbFJSUkFDnJUSgYzj/fETy4em39aZluGZz5A+QDDYN9ZpAdVJbtcAyqWDcfP4rotkfT0dIKD3X+WLU/JAzwjl7CwMGrWrElWVhYWi3MaNaGhoQwYMIBXX30VgNGjR5Oens6zzz5r1/lszaV9+/a88sorxMTEXLb+5MmT/PTTTwCsW7eO4cOHM2/evCuea8+ePaxevZquXbvaFXNesrKySE1NpWvXrqxevfqq++7cuZNjx45dtC4xMTElV+/HBba2wG8wxuwVkXLADyKyNfdGY4wRkTz/EhhjPgE+AYiLizP2PI3UujUkL5pOk5hGnD15lJNH9nFy/26uIYLHTS0OpO6k855v8TmTCYdhx+Zr2BHUmAM1u9Eg7gYaVSqNxct1Cro+XeZ6PCGXLVu2EBIS4tQv/vz8/Jg7dy4jRowgIiICPz8/zp07Z3c853MxxmCMwcsr715fi8VCUFDQZe9jsVg4dOgQy5cv59ZbbyUoKAiLxXLVeA4dOsScOXN44IEH7Io5L0eOHCE4OBgvL698fxf+/v40btzYpvPa1AdujNlr/fcAMAdoAuwXkQoA1n8P2PSOdhKLL0Gly1E6qjZRDVpx7Y19aH1jRwbdVJvX+7bHZ/g+0nsv5I/owVhKVyIx40dWrltPlzEr6fLKZL4c+yKLf1lPxrmsogxTqRLN29ubfv36MWrUqMu2HTx4kC5duhAfH098fDwrVqwA4MUXX+Ttt9++sF/9+vX5888/+fPPP4mJiaF3797Ur1+fv//+m0ceeYS4uDjq1avHiBEjbIppyJAhjBw58rL1WVlZDBkyhPj4eBo2bMjHH38MwDPPPMOyZcto1KgRo0aNokOHDmzYsAGAxo0b89JLLwHwwgsvMG7cOIwxDBkyhPr169OgQQNmzJgB5DQKEhIS6Ny5M/Hx8Re9965du2jcuDFr1qyxKYcrybcFLiJBgJcx5oT1dTvgJeAb4D7gdeu/XxcqksLy9iW4elOCqzfNWc46x5unz9Hhj6NkrviAO//9EOaNYsN3Nfmj/C2Ua9aDJg2vw8eizzIpz/Pfbzex+Z/jDj1n3YqhjOhUL9/9HnvsMRo2bMjQoUMvWj9w4ECeeuopbrjhBv766y9uvvnmfO+N/uOPP5gyZQrNmjUDYOTIkYSHh5OVlUXbtm3ZsGEDDRs2vOo5mjdvzpw5c0hOTr6o9Tt+/HjCwsJYs2YNZ86coUWLFrRr147XX3+dt99+m7lzc6Y5PXPmDMuWLaNKlSp4e3tf+MOzbNkyxo4dy+zZs1m/fj2//fYbhw4dIj4+npYtWwI5XTYbN24kIiKCtLQ0ALZt20b37t2ZOHEi0dHR+f4+r8aWLpRIYI7121Fv4HNjzAIRWQPMFJEHgD2A4zqMHMHiQ1iwD52jAyH6VTL/7UXqqlmEb/2Ghvs/4ORX40j4ZjxtGlbljkYViKuqt18p5QihoaH07t2b0aNHExAQcGH9jz/+yObNmy8sHz9+nPT09Kueq3LlyheKN8DMmTP55JNPyMzMZN++fWzevDnfAg4wfPhwXnnlFd54440L6xYuXMiGDRuYNWsWAMeOHWPHjh34+vpedGxCQgKjR4+mWrVqdOjQgR9++IFTp06xe/durr32WsaOHcs999yDxWIhMjKSVq1asWbNGkJDQ2nSpAnVqlXjxIkTQM6nkNtuu43Zs2dTt27dfOPOT74F3BizC7jsz4QxJg1oW+gIiol3+euoevvzwPOc/XcLu9b/TJMjUcxZt5fbfn2QJT7hpNfpSmzbu6gY7v4PDqiSzZaWclF68skniYmJoW/fvhfWZWdns2rVKvz9/S/a19vbm+zs7AvLue+DDgwMvPB69+7dvP3226xZs4bSpUvTp08fm++ZbtOmDcOHD2fVqlUX1hljeP/997n55psv2nfJkiUXLcfHx7N27VqqV6/OTTfdxKFDhxg3bhyxsbH5vu+lQ8iGhYVRuXJlli9f7pACXiL7D3zLX0eDWx5g9D2NWftsa8pUjyHWbKLTpiexvFefb//Xjx9XrNL+cqXsFB4eTteuXRk/fvyFde3ateP999+/sLx+/XogZ5jpdevWATldDrt3787znMePHycoKIiwsDD279/P/PnzCxTT8OHDefPNNy8s33zzzYwZM4Zz584BsH37dk6ePHnhi+DzfH19qVSpEl988QXNmzcnISGBt99++0I3SUJCAjNmzCArK4uDBw+ydOlSmjRpkmcMvr6+zJkzh8mTJ/P5558XKP68lMgCnltQgD81+4wh9NmdHGw/nvTw+tx64gt+mDeLJiN/5MVZv7Dhj1Rsud1SKfX/nn76aQ4dOnRhefTo0axdu5aGDRtSt25dxo4dC0CXLl04fPgw9erV44MPPqB27dp5ni86OprGjRtTp04devToQYsWLQoUT/v27Slb9v/nRHjwwQepW7cuMTEx1K9fn4cffpjMzEwaNmyIxWIhOjr6wpexCQkJlCtXjoCAABISEkhNTSUhIQGAO+64g4YNGxIdHU2bNm148803KV++/BXjCAoKYu7cuYwaNYpvvvmmQDlcyqb7wB0lLi7OuMOEDtnH9rF63zlm/naY8E0TeFqms9y3Beca9qB5YmfCg/0KdX5PuGUNPCcP8IxctmzZwnXXXecx44dAyRoL5bzz1zE3ESnUfeAlildYBZqHQfM6lUnfcx///HiCG1LnEZiymL/WlmNFRCdK3zyM62tG4OVC95crpUoWLeD5CK4SQ80HPoOzp/hn1Uyy1kyiQtpK7vrsF6JKB/BE7SPc0PJGKpYJc3aoSqkSRgu4rXwDqdiyD7TsQ4XTp3h/+1Hmr9rA7esf4sT6QBaEtiOoeV+aNmmBr3eJ/2pBKVUMtIDbwT8gkE7RgXRqEMnB9ZM5snw8Nx7+Cu+FX7J+4bWk1BtGq1Y3UbOce4+toZRybVrAC8PLQtmYjpSN6UjWiQPsXPQpkZuSmPzrcV5O+Ym7K6Zx83URXN/yJgL9bJthQymlbKUF3EEsIeWoefuzcNswZqWfZc6vqdRZ+hgtV6xk+/LKbLvmDqq1uZ96Nao4O1SllIfQzlpHE6FsiB/9WtYg4ekk/mw+koCAQDr98x61psQx6/X7+eHPcxw9ddbZkSrlcBaLhUaNGhEdHU1MTAw///yzXefp06fPhUfci8OVhhI+n8/5n9dff/2q55k4cSIDBgwoihDzpC3wIiQBpah68wC4eQDpe34ldfEnHD0UwrStZ/nq1QWMLL+ca1r2JrZ+Pb0dUXmEgICAC09Yfv/99wwbNuzCWNyuIjMzE29v20pf7nycHUtetAVeTIKrNKZO3zE8NORNXrren6HXHeH2Qx8T8+UNrHzlRubOHMe+w44dPU4pZzp+/DilS+dMlZuenk7btm2JiYmhQYMGfP31/w9eOnny5AtPMvbq1euy8zz//PP06dOH1atXc+eddwLw9ddfExAQwNmzZ8nIyKB69eoAjBs3jvj4eKKjo+nSpQunTp0Cclr0/fv3p2nTpgwdOpTdu3fTvHlzGjRowPDhwwucW9WqVS88Zbp27do8HwLLPXxuq1atLho+t1evXrRo0SLPfAtCW+BOUDnUQuvO93Fm//XsWfQxdXd+SenNgzmw6RUGV/qQG5vF0fa6cjrUrSqcCR0uX1fvdmjyEJw9BdPuvnx7ox7QuCecTIOZvS/e1ve7fN/y9OnTNGrUiIyMDPbt28fixYuBnEkK5syZQ2hoKIcOHaJZs2Z07tyZzZs388orr/Dzzz8TERHB4cOHLzrf8OHDOXPmDBMmTCArK+tCa3jZsmXUr1+fNWvWkJmZSdOmOcNI33nnnTz00EMXjh0/fjyPP/44AKmpqfz8889YLBY6d+7MI488Qu/evfnwww/zzee8YcOG0a1bt3x/D3Dx8LmbN2+mS5cuF4bP3bx5M8uXL79otEZ7aAF3Ir/IWtTu8TZkvc7Bdd/yz9pvWLbfj1lTU3gwcCl1a9emWbtuVAzX2xGVe8jd5bBy5Up69+7Nxo0bMcbw7LPPsnTpUry8vNi7dy/79+9n8eLF3H333URERAA5g2Cd9/LLLxMTE8OECROAnFELa9SowZYtW/jll18YNGgQS5cuJSsr68K4JBs3bmT48OEcPXqU9PT0i0YavPvuuy9Mz7ZixQq+/PJLAHr16sV//pP3dL6F6ULJPXxudnb2RcPndu7cudDFG7SAuwaLN2Xj76Bs/B2syMrmp237qTvnGSpsHUvqlleZHX4bFdv0o0m9a7WvXNnuai1m38Crbw8qY1OL+2qaN2/OoUOHOHjwIPPmzePgwYOkpKTg4+ND1apV8x0KNj4+npSUFA4fPnyhsLds2ZL58+fj4+PDjTfeSJ8+fcjKyuKtt94CcrpKvvrqK6Kjo5k4ceJFQ8NeOrRrYcb/zz0E7pXyyD187qVjoVwai730M7qL8bZ40bZuBSo8s45Dt44jK6wKdx4ZT8ys63nnjef4dNkujp065+wwlcrX1q1bycrKokyZMhw7doxy5crh4+NDcnIye/bsAXLG6f7iiy8uzFaTuwvllltu4amnnqJDhw4XhndNSEjg3XffpXnz5pQtW5a0tDS2bdtG/fr1gZxBoypUqMC5c+eYNm3aFWNr0aIF5ydYv9p+V1K1alVSUlIALrTkL3Wl4XMdyeYCLiIWEflVROZal9uIyDoR2Sgik0REW/OOZPEhomlXqgxazNn+q/i7Rg/2B9Xhle+20Ou1z5j1yUg2/rnf2VEqdZHzfcaNGjWiW7duTJo0CYvFQs+ePVm7di0NGjRg8uTJ1KlTB4B69erx3HPP0apVK6Kjoxk0aNBF57vjjjt46KGH6Ny5M6dPn6Zp06bs37//wljcDRs2pEGDBhda0y+//DJNmzalRYsWF94jL++99x4ffvghDRo0YO/evTbl06hRI5555hkARowYwcCBA4mLi7vQLXOp3MPnxsfHXxg+15FsHk5WRAYBcUAo0JmcadTaGmO2i8hLwB5jzPirncNdhpMtaoXJZfM/x9n/1bMkHphCmglhUVAHSrd6hMS4hngX85eeek1ciw4n67qKajhZm/6PF5EooAPwqXVVGeCsMWa7dfkHoItN0alCqVsxlMRH3ufkPV9xslwsd52aQat5bfj61R58umwXxzO0e0WpksKmFriIzAJeA0KAwUAn4E+gizFmrYi8B7QxxjTI49h+QD+AyMjI2PP9TgWVnp5+xael3I0jc/E79Q9+O75lywl/nku/C3+LoX/ZzVxTK4ayQUXbq6XXxLWEhYVRs2ZNsrKyrvix3t14Si4FyWPnzp0cO3bsonWJiYn2TeggIh2BA8aYFBFpDWCMMSLSHRglIn7AQiDPCSSNMZ8An0BOF4q9H1M94SPueY7PpQcxQMPUYyz9fhaP/T2S7auvYWWFXjRq/yDRVcrmewZ76DVxLVu2bCE4OJj09HSP6HaAkteFYozB39+fxo0b23ReW7pQWgCdReRPIAloIyJTjTErjTEJxpgmwFJg+9VOoopeg6gwHutzH0dv/YhSwQHct/91ynzWjEnvPssvO/5xdniqiPn7+5OWlqbzt7opYwxpaWn4+/vbfEy+LXBjzDBgGIC1BT7YGHOviJQzxhywtsD/A4y0K2rlWBZvSjXtCU16cGrTd1gWvsmtR6dzw/gmRFctx2Ota9Dq2nKFugdWuaaoqChSU1M5evRogYqAK8vIyPCIXGzNw9/fn6ioKJvPW5hO0iHW7hUvYIwxZnEhzqUcTYTA+h0JrN+RjCP/8OzmM3z20zZKfX4LnwUnUvnmx7mxYVUt5B7Ex8eHatWqsWTJEps/grs6T8mlqPIo0H1nxpglxpiO1tdDjDHXGWOuNca86/DIlMP4l65InxbV+PGRhpQvF8kDp8YTPbs14/73DCu2XvkeWKWUa9MnMUsQ39IVKT9gAZm950KZmvRLH0vV6QkM+OgbUvYccXZ4SqkC0gJeAnlXT6Dc4z9ytsdsTl7TklVp/nQZ8zNDP53L9n91SFul3IU+/l5SieBbuy21a7flpzOZJC35la4rO/HbRzX44brB3NO5A+FBvs6OUil1FdoCVwT5efNA22i82jxHjM8eHtnal0Vv3cO0xb9yLivb2eEppa5AC7jK4e1LUMvHCRz8O8eiH+BOFnPLT53o+s63/LT9oLOjU0rlQQu4ulhAaUrf+T+8+i/jSHQ/jkoY9332C89N+ZGDJ844OzqlVC7aB67yJOXrU/PO+izIzOKL7xbQdV03pvyvA8E3P8/dTWvqxBJKuQBtgaur8vO2cG+768moexcP8DUx82/juQ8msOtgurNDU6rE0wKu8hdQmtBuH2N6zuKawExeOTyIhe8/xo97zum4G0o5kRZwZTOpdROBT67hTP2eRJYKYeqWs/T+7Bf2HTvt7NCUKpG0gKuC8Q8j8K4Puf3J0fSu64vvnz8xbtTzfPebjnaoVHHTAq7sIl5etKnsw3t1t/IC42DWfbz65UrOZOY5LLxSqghoAVeFEtztUzLbvMgt3in03nAvQ9+fzJ60k84OS6kSQQu4KhwvL7xbPoXl/u8pE+TLG8eGMHD0dH7YvN/ZkSnl8bSAK8eoFE/Ao0vJaP402RHX0m/KWj5M3ql3qShVhLSAK8cJLkupm4cxs//19K1jqLj4CZ75fDkZ57RfXKmiYHMBFxGLiPwqInOty21FZJ2IrBeR5SJSs+jCVO7E38fC8zEZdPZexYPbHmbAR19z4HiGs8NSyuMUpAU+ENiSa3kM0NMY0wj4HBjuwLiUm5MGd2Hp/RVV/Y4z8vAghnz4uT69qZSD2VTARSQK6AB8mmu1AUKtr8MAvRFYXaxaS3we/J7SQX58eOY5ho+Zxm9/H3V2VEp5DLHlSyYRmQW8BoSQMyt9RxFJAL4CTgPHgWbGmMumcxGRfkA/gMjIyNikpCS7Ak1PTyc4ONiuY12Np+Riax5+GQcpv2MavdN6c+CcHwMa+dGgrGuNo+Yp1wQ0F1dU2DwSExNTjDFxl20wxlz1B+gIfGR93RqYa309G2hqfT0E+DS/c8XGxhp7JScn232sq/GUXAqax/7jp80doxaY3s++Zub/vq9ogrKTp1wTYzQXV1TYPIC1Jo+aakszqAXQWUTaA/5AqIh8B9Qxxqy27jMDWGD3nxdVIpQL8Wd6zUV4Hx3H4KQTmG4DuLVBBWeHpZTbyrcP3BgzzBgTZYypCnQHFgO3AWEiUtu6201c/AWnUnnyu+kFTOXmvO39EQtmfMjcDfrViVL2sus+cGNMJvAQ8KWI/Ab0IqcbRamr8wvG+95ZULk573h/yHczxvGtDoSllF0K9E2SMWYJsMT6eg4wx/EhKY/nG4il5wyyJt3Of/dPo/WMRgT5NaNNnUhnR6aUW9EnMZVz+IVg6fUlgQ99R40KZXhk6jpW70pzdlRKuRUt4Mp5AkoRXL4Wk/rG8VzgHEZO+pqNe485Oyql3IYWcOV04eYoPb0XMdbrNZ4a/70+samUjbSAK+cLKY+l5xeU905ndPZrPDZhKYdPnnV2VEq5PC3gyjVcE4PX3ZOoI3sYlv46j0xapaMYKpUPLeDKddRuh3R6lxbeWzj79zqGzNpAdraOJ67UlbjWgBRKxfTGUj2RduvP8saCrVQJD2Twzdc6OyqlXJK2wJXrKVWJ/q2q81qtraz76Stmr0t1dkRKuSRtgSuXJFnn6J4xk45+e7l9diQ1y91Ow6hSzg5LKZeiLXDlmrx9kXumE+TnzTift3lq8nIOpZ9xdlRKuRQt4Mp1hVfHq+tEqvEPwzJG8djUtZzLynZ2VEq5DC3gyrVVb43c8ho3eq0l4K8lvDJ3s7MjUsplaB+4cn1N+kGFaGr9Hsq4ZbupVzGMrvGVnB2VUk6nLXDl+kSgcjP+c0sdelU+zLivfmC9zq2plBZw5T68zTn+e2okY31HMWiKfqmplBZw5T68/fC64yOqk8rTGR/w+LR1ZOqXmqoEs7mAi4hFRH4VkbnW5WUist7684+IfFVkUSp1Xo02SJvn6eC1krp/TeGNBVudHZFSTlOQFvhAcs17aYxJMMY0MsY0AlaSM0u9UkXvhqegTkee9Uli1fJFOiWbKrFsKuAiEgV0AD7NY1so0Ab4yqGRKXUlInD7GEzbFwio1Iihszaw7d8Tzo5KqWJnawv8XWAokFeH4+3AImPMcQfFpFT+/EPxTniSD+6Np7JfOgMmr+TY6XPOjkqpYiXGXH24ThHpCLQ3xjwqIq2BwcaYjrm2zwc+NcZ8eYXj+wH9ACIjI2OTkpLsCjQ9PZ3g4GC7jnU1npKLK+RhyTxJ49UD+DajEUmlHmZgjB9eIgU+jyvk4iiai+spbB6JiYkpxpi4yzYYY676A7wGpAJ/Av8Cp4Cp1m0RQBrgn995jDHExsYaeyUnJ9t9rKvxlFxcJo8fXjRmRKgZ+uzTZtQP2+w6hcvk4gCai+spbB7AWpNHTc23C8UYM8wYE2WMqQp0BxYbY+61br4LmGuMybD7T4tShdVmOKZ6IiN9J5K8aD6Ltux3dkRKFYvC3gfeHZjuiECUspuXBbnrMyyh5fk0YDQvzfiJ3YdOOjsqpYpcgQq4MWaJydX/bYxpbYxZ4PiwlCqgwHCk21SCqsWTLd70n5LCyTOZzo5KqSKlT2Iqz1GxEYG9kni1RwJ/HDjGf77ccP57HKU8khZw5XESKnqxIuJ1zMY5jF++29nhKFVktIArz+MXQrlSwfzP7xO+XPADP/9xyNkRKVUktIArz+Pti3SdhG9gGOP8RvHctKX8c/S0s6NSyuG0gCvPFFIer25TqCiHeTvrDR6fspKMc1nOjkoph9ICrjxX5aZ43TGGOqFn2Ls3lUEz15OVrV9qKs+hBVx5tvpdCBr4Cw92uIF5v+/j5bmb9c4U5TG0gCvP5+3Lg9dX4tuKk5HVY/hk6S5nR6SUQ2gBVyWEUL+cLyN8prDt+0/4ev1eZwekVKFpAVclg8UbuWs82dVa8ZbvJ8z/YjwLN/3r7KiUKhQt4Krk8PbDq/vnUDGG933eY8b0z0jedsDZUSllNy3gqmTxC8Zy7xdIpXgiwkvz8JQUlu/QB32Ue9ICrkqewHC875/PMw8/QPWIIEZM/o6Nh/QeceV+tICrkkmE0kG+zLzhXxZYBrHz18XM/32fs6NSqkC0gKsSLbT+zUilJrzr8wFrZoxk5pq/nR2SUjbTAq5KNv8wvHvPYX+ZZrzgPYW0r4fxUfIOfdhHuQWbC7iIWETkVxGZa10WERkpIttFZIuIPFF0YSpVhHz82VJ/KFkxfXjE+1uWLPyaobM2cDYz29mRKXVV3gXYdyCwBQi1LvcBKgF1jDHZIlLOwbEpVXzEgqXTu2Q3uJtmO8sxetEOUtOO8VGvZpQO8nV2dErlyaYWuIhEAR2AT3OtfgR4yRiTDWCM0RtqlXsTwavaDQy6qTaT28Gb++5n+OhxbNx7zNmRKZUnW7tQ3gWGArk/U9YAuonIWhGZLyK1HB2cUs7Ssn4NyoYF8d6Z4Xw3dhhTV+7WfnHlciS//yhFpCPQ3hjzqIi0BgYbYzqKSDowwhjzPxG5E3jKGJOQx/H9gH4AkZGRsUlJSXYFmp6eTnBwsF3HuhpPycVT8oC8c7FknqTGlg+omPYzP2Y1Jin8Mbo0iCDAW5wUpW08/bq4o8LmkZiYmGKMibtsgzHmqj/Aa0Aq8CfwL3AKmApsBapZ9xHgWH7nio2NNfZKTk62+1hX4ym5eEoexlwll+xsk7VyjMl8MdyMfK6/ueGNRWb1rrRija2gSsR1cTOFzQNYa/Koqfl2oRhjhhljoowxVYHuwGJjzL3AV0CidbdWwHa7/7wo5apE8GrWH8sjK7jp/v8iCC+Pm8bbX/+iM/wopyvIXSiXeh2YJiJPAenAg44JSSkXVK4O8eVg/mNBZL77EOnrsnlh2xN07dqbuKrhzo5OlVAFepDHGLPEGNPR+vqoMaaDMaaBMaa5Mea3oglRKdcRFBRE2H1JlA4L481TI9g7vievTF/MkZNnnR2aKoH0SUylCioqjsDHf+ZsiyF08F7DwK096PX2DGau/ZtsnXNTFSMt4ErZwycA35uG4z1gNWfi+uNftjpDZ23gwdFzWLUrzdnRqRJCC7hShVGmBhGdXmRm/+sZ0zmSMUcfJn1CF0Z8OotdB9OdHZ3ycFrAlXIALy/h1vh6eCUOI8F3By/8/SBrR9/LGzMX8++xDGeHpzyUFnClHMUnAJ9Wg/B7+nfOxPXjTu/lPLbpHjq99S0vfrOJA8e1kCvHKsxthEqpvASGE9jpTbjhUc7+/j1tDlzLlFV7yFwzgYjGHel5U3PKhvg5O0rlAbSAK1VUSlclvOXDvAE8Hh9E+Ym9yPptArPWt+Gf+g/TtW1zqpQJcnaUyo1pF4pSxSCqSg28n0jhbP3udLMsZuCmrqx5tzvPTl7I76k62qGyjxZwpYpL6aqE3P0h3gPXk9n4Pm71+52f/jhBpw+W0//jBSzddkBHPFQFol0oShW3UpUIvH0UdHyd+ZlefL5qD61+6grTzvFGYBcqtbyX22OrEuSn/3uqq9MWuFLO4u1HqL8P/VtWp2aHJ7kmzIdnMkbR7vs2THmtH+/NXsJfaaecHaVyYVrAlXI2Ly984noTOigF03MWPpVi6cds9q+bS6u3k+k3cTXLtx/U7hV1Gf2MppSrEEFq3USpWjfB4d08kR1GmXUHyVo5ljK7fuCdgE6EN7uX25vU0nk6FaAFXCnXFF6N8sDT7cI5W6E1p35YwdPHP+L4kol8nZzAP9W70aZ1InFVSiPi2jMEqaKjBVwpF+fb4DZ863eGv1djlo2l+87vWL/7b+7e6k+tcsHcG1+B2+OqERbg4+xQVTHTAq6UOxCBys0I69kMTh2m/tF/eWNvMPNWrqfjjz2Z+0Nz9te6h8RWidpXXoJoAVfK3QSGExAYTreK0K2m4eh3N9L1j+/w+WMhv+6oySqfG9nnW4GOsTUI9ddWuSez+S4UEbGIyK8iMte6PFFEdovIeutPoyKLUimVt9JVKHXvRHyGbCOj7UiqhWTzn6yP+fDbVTQduYjhM39h/d9HtVXuoQrSAh8IbAFCc60bYoyZ5diQlFIFFhiOf8IA/G94jF++m8RH0bcz/Ze/uGnDE5iNJ3g3uAORLXrQKbYGIdoq9xg2FXARiQI6ACOBQUUakVLKfiKcCq5Kk0qliK5UiozIrmSsHEfjk+9xfOE4vvk+gX9r9+TGVq1oGBWmd7C4ObHlo5WIzAJeA0KAwcaYjiIyEWgOnAEWAc8YY87kcWw/oB9AZGRkbFJSkl2BpqenExwcbNexrsZTcvGUPMDDczGG0KObCP3reyofWcn7WXfy/rnbqB6cTWKUEBcVRIC3axZyT7kuhc0jMTExxRgTd9kGY8xVf4COwEfW162BudbXFQAB/IBJwAv5nSs2NtbYKzk52e5jXY2n5OIpeRhTgnI5mWaOHzloJq/807z25svm2AvlzdQX7jbvTJ1t1v91xGRnZxdbnLbwlOtS2DyAtSaPmmpLF0oLoLOItAf8gVARmWqMude6/YyITAAG2/3nRSlVPALDCQmEXs0iMJU7cmTRdrrtmof3ju9J2VaLd4I7Uj6hN50bV9K+cjeQbwE3xgwDhgGISGtyulDuFZEKxph9ktOJdjuwsQjjVEo5mFRsRHivyXAyjYyUqdRc/RkRp2fR6us4Rs7fzj31Auh8fbT2lbuwwtwHPk1EypLTjbIe6O+QiJRSxSuoDP4tB+Kf8ASh6fuZc8SPWau28eSm29m2qRLvhHSgwvU96BRbTVvlLqZABdwYswRYYn3dpgjiUUo5iwgSUp7GIdA4sj4Zkc9Qa/VnxJ0cxaGF45m68EYO172PLq1iqFM+NP/zqSKnw8kqpS7nF4x/qycJG/IbptdX+FRuwsMyh5TfN3HLu8voM+4nftz0L9nZ+oCQM+mj9EqpKxNBaiQSViMRju1lvHdZpq/5i8pLB1N2xh5e8+9EpYSe3NmkBsE6g1Cx09+4Uso2YddQGni0dU0yg+/g9JJ3eS79PQ7+OIEpP7bjVKO+dG0VQ6XwQGdHWmJoF4pSqsC84+4jZFAK3Dsb38pxPCKzKLPufVq9lcyAz9ex6Z9jzg6xRNAWuFLKPl5eULMtYTXbwqEdtD/jw74Np9m2agG7tzzDzGt6077drTSpFq63IRYRLeBKqcKLqEU5YNg1cCoiBcuCjXT89zFWTKjHiDL30vKmO2lzXSReXlrIHUm7UJRSDhUYfy9+Q7Zyru1/aRx4gJeODuNsUi/aj17Ggo37dGhbB9IWuFLK8fxD8Ul4Ep9m/clKmUiFfac5uyubR6eu5a6yqbS75Q7a1o3UrpVC0gKulCo6Pv5YmvWnMbAwK5uUeeNpmvIMq2dM5NnS93NLhztpWStCC7mdtAtFKVUsvC1eNL2lF1m3vEHDgDReOzaUs1O68eSHM1n31xFnh+eWtIArpYqPtUUe8PQGMlsPp5XvVgYeeok7P1rBgM/X8ffhU86O0K1oF4pSqvj5BuLdegjE96XCoT08sT2EqUs3MWPLJ5gmD9GvbUPCAnXgrPxoAVdKOU9QBAFBEQyqAveHraPUvOn8s/Z7XlnXh5hb+hCpd6xclXahKKVcQqkm3eH+7ykdUYG3zDtEze3BpJ93sXGvPtV5JVrAlVKuo3IzAh5dirn1TZr67eHhsxPo/MFyXvxmE8czzjk7OpejXShKKddi8UaaPoxvvTvISF7MvdlV+G7levb+tpiuXbpyU91IZ0foMmxugYuIRUR+FZG5l6wfLSLpjg9NKVWiBZfDK6Q8L91WnwWNVvJx1vOkfv44/5m+kqOnzjo7OpdQkC6UgcCW3CtEJA4o7dCIlFLqEmVufx0T/xB9vb/nsa29+c//xvDj5v3ODsvpbCrgIhIFdAA+zbXOArwFDC2a0JRSysovGEuHt6DvfCLDAhmTNYJvpr7H4C9+4+SZTGdH5zRiy8AyIjILeA0IIWdW+o4iMhDwMsaMEpF0Y0zwFY7tB/QDiIyMjE1KSrIr0PT0dIKD83wLt+MpuXhKHqC5uKq8cvHKyqDKrmmMybyNGXsCiAwSHon2o0qoxUlR5q+w1yQxMTHFGBN32QZjzFV/gI7AR9bXrYG5QEVgOeBtXZ+e33mMMcTGxhp7JScn232sq/GUXDwlD2M0F1eVXy4/b//HrHixlXl8+Atm4ordJjs7u3gCK6DCXhNgrcmjptrShdIC6CwifwJJQBtgE1AT2GldHygiO+3+86KUUnZoXsGb+PJejLa8S/a8oTwxbU2J6lLJt4AbY4YZY6KMMVWB7sBiY0xpY0x5Y0xV6/pTxpiaRRyrUkpdLLgsPg9+j2n2KH29v+ee7QPp++F8/korGWOq6IM8Sin3ZvFBbnkNbh9LM++dDDr+Bp0+WM7S7QedHVmRK9CDPMaYJcCSPNZ7xjcmSin31egevCJqU+WUFxXmnaDPhNUM71CP+2+o5uzIioy2wJVSniMqlgq1GzP7keZMKDudffPf5OVvN5Gd7ZmDYmkBV0p5nEBvSIjy4Tmfz4la/V+e+HwtGeeynB2Ww2kBV0p5HosPXnd9duHLzVu3Pcv9ny7n2GnPGhBLC7hSyjN5eeV8udluJB0sv3Dfvlfo+ekqjpz0nHFUdDRCpZRnu34A+IdS/lgg2xelc8+4VUx5oCllQ/ycHVmhaQtcKeX5YnoTnXgXn90XT420Jdz/8SL+PZbh7KgKTVvgSqkS44bIs1zv8z7rT1Sj7yfCpP6JlAvxd3ZYdtMWuFKq5AitiFeXT2jstYMR6S/z4Lilbt0nrgVcKVWy1LsDueNjmspmhhx9mfvHr3Db6dq0gCulSp6GXZHO75PgtYHKBxbxwMQ1nDrrfoNgaQFXSpVMMb2g30+06/oYKXuO8Pjnv5KZle3sqApEC7hSquSq2IgODSvwQWsvIndMZ8Q3m87Pg+AWtIArpUq89qe+4VWf8Rxfk8SYn/5wdjg20wKulFIdR2EqX88o37EsWzibr9fvdXZENtECrpRSPv7IPZ/jVbYm4/ze44MvFrBqV5qzo8qXFnCllAIIKI1Xj5kE+vvxeOBCHp22jr8Pu/bMPjYXcBGxiMivIjLXujxeRH4TkQ0iMktEdFIHpZR7K10FrwcWUv/Bj8nMyuahyWtdeo7NgrTABwJbci0/ZYyJNsY0BP4CBjg0MqWUcoaImlSPLMXHd1Qi/uBsBs1c77ITQthUwEUkCugAfHp+nTHmuHWbAAGAa2aolFJ2aJ42m5d9JhC05QveW7TD2eHkSWy551FEZgGvASHAYGNMR+v6CUB7YDPQwRhzWYeRiPQD+gFERkbGJiUl2RVoeno6wcGe0UvjKbl4Sh6gubgqZ+Yi2Zk03PAiwUe3cPeZF2gRXY/48vaN/1fYPBITE1OMMXGXbTDGXPUH6Ah8ZH3dGph7yXYL8BHQN79zxcbGGnslJyfbfayr8ZRcPCUPYzQXV+X0XE6mmexRDczB/1YzLZ+fbnbsP27XaQqbB7DW5FFTbelCaQF0FpE/gSSgjYhMzfUHIMu6vovdf16UUsoVBYYj3adRxusUQy3T6D91nUt9qZlvATfGDDPGRBljqgLdgcVALxGpCRf6wDsDW4syUKWUcoryDZAeM4i4+112HUxn6JcbXOZxe3vvAxdgkoj8DvwOVABeclhUSinlSqq3omndGjzTrjr//r6E8ct3OzsioIAz8hhjlgBLrIstHB2MUkq5socyJtHX/1PuWuBLw6geNKkW7tR49ElMpZSykbQcjCUkkk983+W5ackcOO7ceTW1gCullK2CIvDqPpWyXsd5+dz/eHzaGs45cQxxLeBKKVUQFRvj1ek9mskmWu39hNfnO+/+DZ2VXimlCqrRPXBiH9n/XMv45buJrlSKztEViz0MbYErpZQ9EgbRr8utxFcpxWuzlrPt3xPFHoIWcKWUspOvtxcTK81jluU5Bk9O5tjp4p3dXgu4UkoVQlCjO6jgdZSh6W/xdFJKsY5cqAVcKaUKIyoOrw5vk+C1gZg/PuT9xTuL7a21gCulVGHF3oeJ6cOj3t+wLXkKi7fuL5a31QKulFIOIO3fJKt6W8qWLsWTSev589DJIn9PLeBKKeUI3n5Yen3Jg/f3R0ToP2Utp84W7ciFWsCVUspRRKgUHsiXMRsYdPi/DJn5a5F+qakFXCmlHKxmZBjtLCnU3voRo37cXmTvowVcKaUcLf5BTKMeDPSezbYl0/n5n6LpStECrpRSjiaCdBhFdsUYRvt9xJqNm9m495jD30YLuFJKFQUff7zuScIntAJ3R/xNrUjHT85scwEXEYuI/Coic63L00Rkm4hsFJHPRMTH4dEppZQ7C4nE8thKKsZ0wM/b4vDTF6QFPhDYkmt5GlAHaAAEAA86MC6llPIMvoFFdmqbCriIRAEdgE/PrzPGzMs15f0vQFTRhKiUUiovYsvsyiIyC3gNCAEGG2M65trmA6wGBhpjluVxbD+gH0BkZGRsUlKSXYGmp6cTHOz4PiRn8JRcPCUP0FxclafkUtg8EhMTU4wxcZdtMMZc9QfoCHxkfd0amHvJ9nHAu/mdxxhDbGyssVdycrLdx7oaT8nFU/IwRnNxVZ6SS2HzANaaPGqqLTPytAA6i0h7wB8IFZGpxph7RWQEUBZ42O4/LUoppeySbx+4MWaYMSbKGFMV6A4sthbvB4GbgXuMMc6b1VMppUqowtwHPhaIBFaKyHoRecFBMSmllLJBgSY1NsYsAZZYX+uEyEop5UT6JKZSSrkpm24jdNibiRwE9th5eARwyIHhOJOn5OIpeYDm4qo8JZfC5lHFGFP20pXFWsALQ0TWmrzug3RDnpKLp+QBmour8pRciioP7UJRSik3pQVcKaXclDsV8E+cHYADeUounpIHaC6uylNyKZI83KYPXCml1MXcqQWulFIqFy3gSinlplyugIvILdaZfnaKyDN5bPcTkRnW7atFpKoTwsyXDXn0EZGD1mEI1lvHlnFJ1hmXDojIxitsFxEZbc11g4jEFHeMtrAhj9YicizXNXHZ4SFEpJKIJIvIZhHZJCID89jH5a+LjXm4xXUREX8R+UVEfrPm8t889nFs/cpriEJn/QAW4A+gOuAL/AbUvWSfR4Gx1tfdgRnOjtvOPPoAHzg7VhvzaQnEABuvsL09MB8QoBmw2tkx25lHay4ZLtlVf4AKQIz1dQiwPY//xlz+utiYh1tcF+vvOdj6+vw8Cc0u2ceh9cvVWuBNgJ3GmF3GmLNAEnDbJfvcBkyyvp4FtBURKcYYbWFLHm7DGLMUOHyVXW4DJpscq4BSIlKheKKznQ15uA1jzD5jzDrr6xPkTHd4zSW7ufx1sTEPt2D9PadbF32sP5feJeLQ+uVqBfwa4O9cy6lcfjEv7GOMyQSOAWWKJTrb2ZIHQBfrR9tZIlKpeEIrErbm6w6aWz8CzxeRes4OxhbWj+GNyWnx5eZW1+UqeYCbXBfr5O/rgQPAD8aYK14TR9QvVyvgJcm3QFVjTEPgB/7/r7JynnXkjDkRDbwPfOXccPInIsHAl8CTxpjjzo7HXvnk4TbXxRiTZYxpRM4cwU1EpH5Rvp+rFfC9QO6WaJR1XZ77iIg3EAakFUt0tss3D2NMmjHmjHXxUyC2mGIrCrZcN5dnjDl+/iOwMWYe4CMiEU4O64qs89F+CUwzxszOYxe3uC755eFu1wXAGHMUSAZuuWSTQ+uXqxXwNUAtEakmIr7kdPJ/c8k+3wD3WV/fRc4MQa72NFK+eVzSF9mZnL4/d/UN0Nt610Mz4JgxZp+zgyooESl/vj9SRJqQ8/+HqzUOgJw7TIDxwBZjzDtX2M3lr4stebjLdRGRsiJSyvo6ALgJ2HrJbg6tXy41KYMxJlNEBgDfk3Mnx2fGmE0i8hI5k3p+Q87FniIiO8n5Qqq78yLOm415PCEinYFMcvLo47SA8yEi08m5EyBCRFKBEeR8QYMxZiwwj5w7HnYCp4C+zon06mzI4y7gERHJBE4D3V2wcXBeC6AX8Lu1zxXgWaAyuNV1sSUPd7kuFYBJImIh54/MTGPM3KKsX/oovVJKuSlX60JRSillIy3gSinlprSAK6WUm9ICrpRSbkoLuFJKuSkt4KrEE5FSIvKos+NQqqC0gCsFpcgZJU4pt6IFXCl4HahhHWv6LWcHo5St9EEeVeJZR8Gba4wp0oGHlHI0bYErpZSb0gKulFJuSgu4UnCCnOm8lHIrWsBViWeMSQNWiMhG/RJTuRP9ElMppdyUtsCVUspNaQFXSik3pQVcKaXclBZwpZRyU1rAlVLKTWkBV0opN6UFXCml3NT/Af2xbrRZa6RuAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Here, plot the solution:\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plot_sampler = tp.samplers.PlotSampler(int_t, 200)\n", + "fig = tp.utils.plot(model, lambda u: u, plot_sampler)\n", + "plt.title(\"Solution\")\n", + "\n", + "# Solution for comparision with backward euler:\n", + "t = torch.linspace(t_min, t_max, 200)\n", + "dt = t[1] - t[0]\n", + "D_fn = D(t)\n", + "u, v = torch.zeros_like(t), torch.zeros_like(t)\n", + "u[0] = H\n", + "for i in range(len(t)-1):\n", + " v[i+1] = 1/(2*dt*D_fn[i+1]) - torch.sqrt(1/(2*dt*D_fn[i+1])**2 - (v[i] - dt*g)/(dt*D_fn[i+1]))\n", + " u[i+1] = u[i] + dt * v[i+1]\n", + "\n", + "plt.plot(t, u, linestyle=\"--\")\n", + "plt.legend([\"Neural Network\", \"Backward Euler\"])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/workshop/Sol3_2.ipynb b/examples/workshop/Sol3_2.ipynb new file mode 100644 index 00000000..96733200 --- /dev/null +++ b/examples/workshop/Sol3_2.ipynb @@ -0,0 +1,681 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise Sheet 3\n", + "\n", + "#### 3.2 Learning the Solution Operator\n", + "Use TorchPhysics and DeepONets to solve the ODE with time dependent $D(t)$:\n", + "\n", + "\\begin{align*}\n", + " \\partial_t^2 u(t) &= D(t)(\\partial_t u(t))^2 - g \\\\\n", + " u(0) &= H \\\\\n", + " \\partial_t u(0) &= 0\n", + "\\end{align*}\n", + "\n", + "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell. Since the installation can take around 2 minutes and has to be redone if you switch to the GPU later." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#!pip install torchaudio==0.13.0\n", + "#!pip install torchphysics" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl\n", + "\n", + "# Here all parameters are defined:\n", + "t_min, t_max = 0.0, 3.0\n", + "g, H = 9.81, 50.0\n", + "D_min, D_max = 0.005, 5.0\n", + "# Size of the data set\n", + "data_batch = 12000\n", + "\n", + "# Number of time points for discretization of D and training\n", + "N_t = 60\n", + "\n", + "# Training parameters\n", + "train_iterations = 10000\n", + "learning_rate = 5.e-4" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "### Function that uses backward Euler to create the dataset (you dont have to understand this cell):\n", + "def data_create_fn(N_t, data_batch, start_height):\n", + " # Time grid (Trunk input)\n", + " t = torch.linspace(0, 3.0, 60)\n", + " dt = t[1] - t[0]\n", + " # Tensors for Branch input and expected output\n", + " D_fn = torch.zeros((data_batch, len(t), 1))\n", + " u = torch.zeros((data_batch, len(t), 1))\n", + " v = torch.zeros((data_batch, len(t), 1))\n", + " \n", + " # Create different fuction types for D_fn:\n", + " # First batch are step functions:\n", + " ind = int(data_batch / 3.0)\n", + " random_steps = D_min + (D_max - D_min) * torch.rand((ind, 6, 1))\n", + " D_fn[:ind, :] = random_steps.repeat_interleave(int(N_t/6), dim=1)\n", + " # Second batch are sinus functions:\n", + " random_fre_amp = D_min + (D_max - D_min) * torch.rand((ind, 1, 2))\n", + " random_fre_amp = random_fre_amp.repeat_interleave(N_t, dim=1)\n", + " sin_fn = random_fre_amp[:, :, 1]/2.0 * (D_min + 1 + torch.sin(random_fre_amp[:, :, 0] * t))\n", + " D_fn[ind:2*ind, :] = sin_fn.unsqueeze(-1)\n", + " # Last batch is exp functions:\n", + " missing_idx = data_batch - 2*ind\n", + " random_start_sloope = (D_max - D_min) * torch.rand((missing_idx, 1, 2))\n", + " random_start_sloope = random_start_sloope.repeat_interleave(N_t, dim=1)\n", + " exp_fn = D_min + random_start_sloope[:, :, 1] * torch.exp(-random_start_sloope[:, :, 0] * t)\n", + " D_fn[2*ind:, :] = exp_fn.unsqueeze(-1)\n", + " # flip some exp functions around t=1.5:\n", + " D_fn[int(2*ind + missing_idx/2.0):, :] = torch.flip(D_fn[int(2*ind + missing_idx/2.0):, :, :], dims=(1,))\n", + " \n", + " # Do time stepping to compute solution\n", + " u[:, 0] = start_height\n", + " for i in range(len(t)-1):\n", + " v[:, i+1] = 1/(2*dt*D_fn[:, i+1]) - torch.sqrt(1/(2*dt*D_fn[:, i+1])**2 - (v[:, i] - dt*g)/(dt*D_fn[:, i+1]))\n", + " u[:, i+1] = u[:, i] + dt * v[:, i+1]\n", + "\n", + " return t.reshape(-1, 1), u, D_fn[:, ::2, :]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Here we create the data\n", + "t_tensor, u_tensor, D_tensor = data_create_fn(N_t, data_batch, H)\n", + "\n", + "### Show an example plot\n", + "import matplotlib.pyplot as plt\n", + "plt.figure(figsize=(16, 4))\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(t_tensor[::2], D_tensor[0])\n", + "plt.plot(t_tensor[::2], D_tensor[4000])\n", + "plt.plot(t_tensor[::2], D_tensor[8000])\n", + "plt.ylabel(\"D\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(t_tensor, u_tensor[0])\n", + "plt.plot(t_tensor, u_tensor[4000])\n", + "plt.plot(t_tensor, u_tensor[8000])\n", + "plt.ylabel(\"u\")\n", + "plt.xlabel(\"t\")\n", + "plt.title(\"Solution for corresponding D\")\n", + "plt.grid()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### a) Shuffle and Split Data \n", + "The above data is created in ordered way (e.g. first 4000 entries belong to step functions). Randomly permute the tensors of $u$ and $D$ along the batch dimension and then split both tensors into a training set consisting of 80% of the data and a testing set with the remaining 20%.\n", + "\n", + "**Hint**: for the shuffling `torch.randperm` may be useful." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Permute data of u, D along the batch dimension and split them into two sets (training and testing)\n", + "\n", + "# Permute \n", + "permutation = torch.randperm(len(D_tensor))\n", + "u_tensor = u_tensor[permutation]\n", + "D_tensor = D_tensor[permutation]\n", + "\n", + "# Then split\n", + "u_tensor_train = u_tensor[:10000]\n", + "D_tensor_train = D_tensor[:10000]\n", + "u_tensor_test = u_tensor[10000:]\n", + "D_tensor_test = D_tensor[10000:]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we start with the TorchPhysics part" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### b) Define Spaces, the Domain and the Sampler for discretization\n", + "The spaces and domain are similiar to before. One also needs an output space for the functions $D(t)$ and then create a \n", + "function space that defines that functions from $[0, 3.0] \\to \\R$ are considered.\n", + "\n", + "Later the BranchNet needs a sampler for discretization of the input functions (even if our training set is already discrete, in the case one later evaluates with a non discrete function).\n", + "The sampler should return **every second value** of the time points in `t_tensor`. For this the `tp.samplers.DataSampler` can be used. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Spaces \n", + "T = tp.spaces.R1('t') # input variable\n", + "U = tp.spaces.R1('u') # output variable\n", + "D = tp.spaces.R1('D') # function output space name\n", + "\n", + "# Domain\n", + "int_x = tp.domains.Interval(T, t_min, t_max)\n", + "\n", + "# Space that collects the Branch functions\n", + "Fn_space = tp.spaces.FunctionSpace(int_x, D)\n", + "discretization_sampler = tp.samplers.DataSampler(tp.spaces.Points(t_tensor[::2], T))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### c) Construct the DeepONet\n", + "Build a DeepONet consisting of a fully connected TrunkNet and BranchNet. Check the `TorchPhysics` [documentation](https://torchphysics.readthedocs.io/en/latest/api/torchphysics.models.deeponet.html), to see how this has to implemented. \n", + "\n", + "Both (TrunkNet and BranchNet) should have 3 hidden layers with 25 neurons each. The output of both networks should be 30 neurons." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "### TODO: Build the DeepONet\n", + "output_neurons = 30\n", + "branch_net = tp.models.FCBranchNet(Fn_space, discretization_sampler, (25,25,25))\n", + "trunk_net = tp.models.FCTrunkNet(T, (25,25,25))\n", + "deepOnet = tp.models.DeepONet(trunk_net, branch_net, U, output_neurons)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "### Create data loader to fit DeepONet to the given data.\n", + "branch_batch_size = len(u_tensor_train)\n", + "trunk_batch_size = len(t_tensor)\n", + "dataloader = tp.utils.DeepONetDataLoader(D_tensor_train, t_tensor, u_tensor_train, D, T, U,\n", + " branch_batch_size, trunk_batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "data_condition = tp.conditions.DeepONetDataCondition(deepOnet, dataloader, 2, root=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 5.0 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "5.0 K Trainable params\n", + "0 Non-trainable params\n", + "5.0 K Total params\n", + "0.020 Total estimated model params size (MB)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dda967d70d5848a8bf3226e1857d7651", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "50dafed2573f4f36bd3936b249a77fe3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### Start training\n", + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate) \n", + "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", + "\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=train_iterations,\n", + " logger=False\n", + " )\n", + "\n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max. absolute error on test set is: 1.4154281616210938\n", + "Relative error is: 0.028308563232421875\n" + ] + } + ], + "source": [ + "### Check error on test set:\n", + "u_model = deepOnet(tp.spaces.Points(t_tensor, T), D_tensor_test).as_tensor\n", + "error = torch.abs(u_model - u_tensor_test)\n", + "print(\"Max. absolute error on test set is:\", torch.max(error).item())\n", + "print(\"Relative error is:\", torch.max(error).item() / 50.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+gAAAEYCAYAAADPrtzUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAACZ1ElEQVR4nOzdd5iTVdrH8e9JpnemMpWh9z40aaMiWFAEC9g7dt21u/vuqru6us11LauyKhZUsIEdRHBEpPfOUKfBdKb35Lx/JMOOSJmS5Elm7s91zcVM8jzJL4EJuXPOuY/SWiOEEEIIIYQQQghjmYwOIIQQQgghhBBCCCnQhRBCCCGEEEIItyAFuhBCCCGEEEII4QakQBdCCCGEEEIIIdyAFOhCCCGEEEIIIYQbkAJdCCGEEEIIIYRwA1KgC7emlJqilFp0musHKaVWuTCSEEK4DaVUslJKK6W8Wnn+NUqp7xydSwghAJRSbyulnnbwbd6olFrpyNtsC6VUklKqQilltv8co5RaoZQqV0r9U9nMVUodU0qtMzqvcH9SoAvDKKUOK6Wq7S9gJUqpVUqpO5RSTf9dPgM81+QcrZTq0fiz1nobUKKUutiF0YUQwuGUUuPsr4OlSqlipdTPSqkRDrz9XxXzWuv3tdaTHXUfQoiOSSmVZi9AfY3O0lRbi3n7+RZ7AV6hlDpkL7Z7NR6jtc7UWgdprS32i2YDhUCI1vpBYBxwHpCgtR7ZlscjOgYp0IXRLtZaBwNdsBXijwJvAtjfmIZqrdec4TbeB253akohhHAipVQI8BXwEhAOxANPAbVG5hJCiDNRSiUD4wENXGJsGqdYrbUOAkKBSUA1sFEpNeAUx3cBdmmtdZOfD2utK1t6x62dHSU8mxTowi1orUu11l8AM4Eb7C96FwA/Nh6jlFph/3ar/VPMmfaf04Bz3e1TWyGEaIFeAFrrD7XWFq11tdb6O631NqWUSSn1f0qpDKVUvlLqXaVU6MluxD4zaVKTn59USs2z/9j4Glpifw0dc+LoklLqLKXUevso/nql1FlNrktTSv3ZPrJfrpT6TikV6finQgjhYa4H1gBvAzec5PpIpdRS++vGj0qpLgD2qd//sr+ulSmltjcWvUqpUPtrXYH9te//Tphhif24X80Msr9W3aqU6gu8Boyxv+aV2K/3VUr9QymVqZTKU0q9ppTyP9ODtL82H9Ba34Xt/emTJ2ZQSjU+B4/Y7/N24I0mGZ6ynzNVKbWlyQzSQU3yH1ZKPaqU2gZU2m93tP24EqXUVqVU6gmP95SvzU1mZ5UopbKUUje25XkQzicFunArWut1QDa2T2IHAnubXDfB/u1g+1SiBfbLc4B6oLeL4wohhKOkAxal1DtKqQuUUp2aXHej/etsoBsQBLzcivtofA0Ns7+Grm56pVIqHPgaeBGIAJ4HvlZKRTQ57GrgJiAa8AEeakUOIUT7cj222YzvA1OUUjEnXH8N8GcgEthiPw5gMrbXpV7YRqevBIrs171kv6wbMNF+Hze1JJTWejdwB/YRcK11mP2q5+z3OQTogW3G0h9bctvAZ9jeq554nzdie3x/s9/n6ydkeEIpNRR4C9vszwjgdeCLEwaargIuAsKAGGyvzU9jm2H1EPCpUiqqyfEnfW22fxjyLbbnM8r+mLc48HkQTiAFunBHR7C9AIUB5c08p9x+vBBCeBytdRm2dYoa+C9QoJT6wv5G9xrgea31Qa11BfA4MMsJUx8vAvZprd/TWjdorT8E9gBNe3zM1Vqna62rgY+wvbETQnRQSqlx2KZwf6S13ggcwFYsNvW11nqF1roW+D220eREbIMrwUAfQGmtd2utjypbs7VZwONa63Kt9WHgn8B1DsirsK0R/63WulhrXQ78xX5/LdH4XrU1ZgOva63X2kfl38G2nGl0k2Ne1Fpn2V9rrwW+0Vp/o7W2aq2XAhuAC5scf6rX5quB7+2zs+q11kVa6y0OfB6EE8i6BuGO4oFi4Bi2F+7mCAZKnBVICCGczT7acyOAUqoPMA94AYgDMpocmoHt/+8TR6na6sT7abyv+CY/5zb5vgrbaL4QouO6AfhOa11o//kD+2X/anJMVuM3WusKpVQxEKe1Xq6Uehl4BeiilPoM28ivP+DNr1/3mr4WtVYUEIBtDXnjZQowt/B2Gt+rtkYXbMs5721ymQ+21+BGWSccf4X6ZUNkb+CHJj+f6rU5EduHJidy1PMgnEAKdOFWlK0xXDywEtu0n16nPwOUUvHYXtj2nulYIYTwBFrrPfa1jLdjG6np0uTqJKAByAMSTji1Etubrkadm97sGe72xPtpvK/FzUsthOhI7OuVrwTMSqnGAtEXCFNKDdZab7VfltjknCBsI89HALTWLwIvKqWisY38PoxtbXc99mZr9lOTgJyTxGhsvBYAlNm/P93rXiG2Jm/97UskW2s68FMrz80CntFaP3OaY5rmzgLe01rf1sr7OlnneEc9D8IJZIq7cAtKqRCl1FRgPjBPa70d+AbbuqOm8rCtR2pqIrDcPnVKCCE8jlKqj1LqQaVUgv3nRGxrENcAHwK/VUp1tb+5/QuwQGvdcJKb2oJt+ru3UioFuLzJdQWAlV+/hjb6BuillLra3pRoJtAPW3d5IYQ40aWABdvrxBD7V19shev1TY670N6ozAfbWvQ1WusspdQIpdQopZQ3tkK7BrDatyv7CHhGKRVsX0f9ALZZRb+gtS7AVrhfq5QyK6VuBro3OSQPSLDfN1prK7ZlRP+yfyiAUipeKTXlTA/WfvtdlVIvAanYdtpojf8Cd9gfu1JKBSqlLlJKnWrW6DzgYqXUFHsGP6VUauP/F2fwPjBJKXWl/XU9Qik1pC3Pg3A+KdCF0b5USpVj+4Tv99iaEt0EoLXeBJQqpUY1Of5J4B17J8or7Zddg61LpxBCeKpyYBSwVilVia0w3wE8iK2Z0HvYurAfwvYm9t5T3M4fsL05PYbtzeMHjVdorauAZ4Cf7a+hTdc7orUuAqba77MIeASY2mTqqhBCNHUDtrXPmVrr3MYvbE0sr2nSJ+MD4AlsU8KHY1tTDRCCrUg8hm0KexHwd/t192Ir2g9im1X5AbbXwpO5DdvIexHQH1jV5LrlwE4gVynV+Fr2KLAfWKOUKgO+5/SNhscopSqwjdCn2XOPsA8mtZjWeoM988vYHvt+7MubTnF8FjAN+B22D1qzsD3eM9ZxWutMbGvVH8T2/G8BBtuvbunzIFxE/W+LPiHcj1JqMnCX1vrSU1w/CFujjTEuDSaEEEIIIYQQDiYFuhBCCCGEEEII4QZkirsQQgghhBBCCOEGpEAXQgghhBBCCCHcgBToQgghhBBCCCGEG3DKPuiRkZE6OTm5RedUVlYSGBjojDhOJbldS3K7jidmhubl3rhxY6HWOspFkVqsNa+h4Jl/Z5LZNSSza3SkzO3xddQT//7AM3NLZteQzK7h8NdRrbXDv4YPH65b6ocffmjxOe5AcruW5HYdT8ysdfNyAxu0E177HPXVmtfQ5j52dyOZXUMyu0ZHytweX0c98e9Pa8/MLZldQzK7hqNfR2WKuxBCCCGEEEII4QakQBdCCCGEEEIIIdyAFOhCCCGEEEIIIYQbcEqTOCGEEEKI1qivryc7O5vQ0FB2795tdJwWaY+Z/fz8SEhIwNvb24WphBCi45ICXQghhBBuIzs7m+DgYCIiIggJCTE6TouUl5cTHBxsdIwWOV1mrTVFRUVkZ2fTtWtXFycTQoiOSaa4CyGEgyilDiultiultiilNtgvC1dKLVVK7bP/2cnonEK4s5qaGiIiIlBKGR2lw1NKERERQU1NjdFRhBCiw5ACXQghHOtsrfUQrXWK/efHgGVa657AMvvPQojTkOLcfcjfhRBCuJYU6E6mtWZbdgk/7y+k3mI1Oo4QwvWmAe/Yv38HuNQp97LlAyIK10P+bqircspdCCGEEEKI//l5fyGb8xscepuyBt1JCitqWbQ5h482ZJGeVwFApwBvzh/QmamD4hjdLQKzST6VFqKd0cB3SikNvK61ngPEaK2P2q/PBWJOdqJSajYwGyAmJoa0tLQW3KuVCSvuZaBugB1PA1DnHUa1fyylob0pDe1HaWhfGrzdbz1vRUVFyx6rG5DMzhUaGkp5eTkWi4Xy8nJDMoSFhdG/f3/q6+vx8vLiqquu4u6778ZkOv24Rksz19XV8Yc//IHFixejlKJPnz7885//JD4+HoCQkBDuuece/vKXvwDw4osvUlFRwe9+97tT3uZPP/2Ej48Po0aNalaG5mSuqanxmH8/QgjhSnN/PsTe7Hp+68DblALdgRosVtL2FvDRhiyW78mnwaoZmhTGszMGEhHow9fbj/LFliN8uC6LyCAfLhgQy9RBsYxIDsckxboQ7cE4rXWOUioaWKqU2tP0Sq21thfvv2Iv5ucApKSk6NTU1Obfq9YwYjebli1kWLcIOHYYn5IMfAr2EnrkG8haZDsuqi90S4W+UyFpDJjMrXiIjpWWlkaLHqsbkMzOtXv3boKDgw1tuObv78+2bdsAyM/P5+qrr6a2tpannnrqtOe1NPNDDz1EbW0t+/btw2w2M3fuXK6//nrWrl2LUgpfX1+++uornnjiCSIjI/H19aW+vv6097Fu3TqCgoKYNGlSszI0J7Ofnx9Dhw5t9uMSQoiOoqCijlBfx9ZxUqA7wP78cj7ekM2nm3IorKglMsiXW8Z15YqUBHpE/+8/vcn9O1NTb+GHPfl8te0oH2/M4r01GcSE+HLhwFguHRLP4MQw4x6IEKJNtNY59j/zlVILgZFAnlIqVmt9VCkVC+Q7/I6VgqBoykJ7w8DUX15XXwM5GyFzFWSsgg1vwdpXISAS+lwIfS+xFe1m2UJJiJOJjo5mzpw5jBgxgieffBKr1cpjjz1GWloatbW13H333dx+++0A/Pvf/+bzzz+ntraW6dOn89RTT3H48GHOP/98hg8fzqZNm+jfvz/vvvsuAHPnzuXQoUOYzbYPy2666Sbeeustli9fzrnnnouXlxezZ8/mX//6F88888wvchUUFHDHHXeQmZkJwAsvvEB8fDyvvfYaZrOZefPm8dJLLzF+/HgXPltCCNGxFJbXkhwgBbrbKK2u52/rq9m1eAVeJsXZfaK5MiWR1N5ReJtPPg3Oz9vMBQNjuWBgLJW1DXy/O4+vth3l/TWZzP35MH+e1p/rxiS79oEI4aEKymuJCvY1OgYASqlAwKS1Lrd/Pxn4E/AFcAPwnP3Pz10azNsPksfavgBqy2H/97D7S9ixEDa9C4FRMPBKGHIVdB7o0nhCnM5TX+5k15Eyh95mv7gQnri4f4vO6datGxaLhfz8fD7//HNCQ0NZv349tbW1jB07lsmTJ7Nv3z4OHDjAunXr0FpzySWXsGLFCpKSkti7dy9vvvkmY8eO5eabb+Y///kPkydPJikp6VdbyaWkpLBz507OPfdcAO6++24GDRrEI4888ovj7r//fn77298ybtw4MjMzmTJlCrt37+aOO+4gKCiIhx56qG1PlBBCiNPSWlNQXsvgTo6dkSgFeitV11m49Z317C228uj5fbh8eEKLC4VAXy+mDYln2pB4ymrqeWDBVv7w+U58vcxcOSLRScmFaB/251dw2auruP/cntw8zi32540BFto7HnsBH2itFyul1gMfKaVuATKAK51x56+mHSA/qx6/g0V0jQwkOtj35N2XfYOh/3TbV0Mt7F8GWz+AdXNgzSu2An3ItTB4JvjLjnBCnOi7775j27ZtfPLJJwCUlpayb98+vvvuO5YvX358KnhFRQX79u0jKSmJxMRExo61fUh27bXX8uKLLzJ58uRm3V9ISAjXX389L774Iv7+/scv//7779m1a9fxn8vKyqioqHDUwxRCCHEGZTUN1FmshPg4tqSWAr0V6i1W7np/IxsyjnHnIF/uTO3e5tsM8fPmlWuGcus7G3j0s234epuYNiTeAWmFaH8KK2q56e11eJsV5/U7ac81l9NaHwQGn+TyIuBcZ963xap5cdk+qustzN25BoAAHzPdogLpHxvKgPgQBsSH0jc2BD/vJp/yevnaprn3uRCqimH7J7DlfVj8KHz/BAy4DFJuhvjhtmn0QrhYS0e6neXgwYOYzWaio6PRWvPSSy8xZcqUXxyzZMkSHnjgAe6///5fXH748OFffVimlKJ79+5kZmb+ag34xo0bmTp16i+O/81vfsOwYcO46aabjl9mtVpZs2YNfn5+jnqYQgghWqCgvBbA4WvQZZu1FrJaNQ9+tJUf9hbwzKUDGRnruM84fL3MzLkuhVFdw3ngo60s3pHrsNsWor2wzV7ZQEF5LW/cMILE8ACjIxnObFLseGoKf5/gz7s3j+RP0/pzZUoinQJ8+G5XLn/4fCfT/7OK/k8s4eKXVvL0V7v4flcepdX1/7uRgHAYNRtu/xFuXwGDr4Kdi+CNc+H18bDxbairNOohCmGYxrXe99xzD0oppkyZwquvvkp9ve33Jz09ncrKSqZMmcJ77713fBQ7JyeH/Hxby4nMzExWr14NwAcffMC4ceMIDAzkhhtu4IEHHsBisQDw7rvvUlVVxTnnnPOLDOHh4Vx55ZW8+eabxy+bPHkyL7300vGft2zZAnC8wZ4QQgjnKqxwToEuI+gtoLXmiS928sXWIzx6fh+uHpVEWtpBh96Hv4+ZN24YwfVvruXeDzcx57oUzu4T7dD7EMJTWaya3yzYzNbsEl67djhDpKnicWaTIirAxIReUUwg6vjlWmtySqrZkVPK9pxSNhw+xrtrMnhj5SGUgv5xIUzoGcU5faIZmtTJtv1j7GC4+AU470+w/WNbY7kv74elf4Sh18GIWyHcLZYVCOEU1dXVDBky5Pg2a9dddx0PPPAAALfeeiuHDx9m2LBhaK2Jiopi0aJFTJ48mc2bNzNmzBgAgoKCmDdvHmazmd69e/PKK69w8803069fP+68804Ann32WR566CF69eqFyWSiT58+LFy48KTLUx588EFefvnl4z+/+OKLx9enNzQ0MGHCBF577TUuvvhiLr/8cj7//HNpEieEEE50fATdRwp0wzy/NJ331mRw+4RuDpnWfipBvl7MvWkk17yxhtvnbWTujSMY2yPSafcnhKd49pvdLNmZxx+n9mNK/85Gx/EISikSOgWQ0CmA8wfEAlBTb2FLVglrDxbz84FCXl9xkP+kHSAswJuJvaI4t28M5/SJJsgvBEbcYpvmnrkG1r0Oa1+D1a9Az8kw6nbofo5MfxftTuOI9smYTCb+8pe/HN+bvKm77rqLRx999BeXHT58GC8vL+bNm/er4319fXnppZd+MRLeVNM15TExMVRVVR3/OTIykgULFvzqnF69eh3fIk4IIYTzGD6CrpQyAxuAHK311DMd39688dNBXlq+n5kpiTx2QR+n31+ovzfv3TyKWXPWcOs7G3j3lpGMSA53+v0K4a7eWXWYN1Ye4sazkt2lKZzH8vM2M7pbBKO7RXD/pJ6UVtfz074Clu/J58e9BXy+5Qg+XiZSe0Vx4cBYzu0bTXCXMdBlDJQdsU133zAX5s2AyF4wcjYMnmVrQCeEEEII0QEUlNfiZVIEOHin2paMoN8P7AZCznRge/Pxhiye/no3Fw7szF9mDDx5Z2Qn6BTow7xbRzHz9dXcNHc97986SvZJFx3S97vyeOrLnUzqG8MfpvYzOk67E+rvzdRBcUwdFIfVqtmYeYyvtx3l2x1H+W5XHj5eJs7pHc30YfGc3bszPmf/DsY/CLs+hzWvwjcPwbI/wdBrYeRtEN7N6IckhNtITk5mx44dRscQQgjhYAXltUQG+WJycG3YrCZxSqkE4CLgDYfeuwdYsjOXRz/dxviekfxr5hDb+kwXigr25f3bRtEp0Jvr31rn8P1ghXB327NLuffDzQyID+XFq1z/O9jRmEyKEcnhPHlJf1Y/di6f3DGGq0cmsSGjmNvf28jIv3zP/y3azqYjVeiBV8DsH+DWZbYp7+vmwIvD4IOZcGA5aG30wxFCCCGEcIrCiloig30cfrvNHUF/AXgEOOX8RaXUbGA22NZJpaWltShIRUVFi89xtl1FFp7fUENyiIlrulSxeuVPvzrGVbnvGwDPrmtg5ms/8buR/sQGta0Bvzs+380huV3HHTIXVlv585oaAsxwc8861q1aecZz3CF3e2EyKVKSw0lJDuf/LurLT/sKWbg5h082ZjNvTSY9ooO4MiWBGcMGEnn5m1D2tK2h3Ia3IH0xRPa2dYYfNAt8g4x+OEIIIYQQDlNQUUtUkC9QdcZjW+KMBbpSaiqQr7XeqJRKPdVxWus5wByAlJQUnZp6ykNPKi0tjZae40zpeeXc/crPdIsO4qPbxxAWcPJPR1yZO2VkJZe9uoqPM3355I6zMLVhJNHdnu/mktyuY3Tm0up6rnhtFVZlZv6dZ9Ezpnnrm43O3V55mU2c3Seas/tEU15Tzzfbj7JgfRZ/+WYPf1u8l3P7RjNrRBITUn+HefyDsHMhrH0Vvn4Qvm+c/n6rTH8XQgghRLtQWF5H384huLxAB8YClyilLgT8gBCl1Dyt9bUOTeJGtNb8YdEOfLxMvHvzqFMW567WNTKQxy/ow8OfbOPTTdlckZJodCQhnKKuwcqd8zZyqLCSd24a2eziXLhGsJ83M0ckMXNEEvvzy1mwPovPNuWwZGce8WH+zBqRyJUjphMzeBZkrbN1fl/3Oqz5D/SaYmsq1+1sMLVtJpAQQgghhBGsVk1hRS1Rwb4Ov+0zvjvSWj+utU7QWicDs4Dl7bk4B/hq21HWHirmoSm96RzqZ3ScX7hsWALDu3TiuW/3UFpVb3QcIZziP2n7WXWgiOdmDOIs2WLQrfWIDub3F/Vj9ePn8srVw0iODOCfS9M567nlzH5vIz/WdMN62Vvwm+0w4SHI2Wjr/v7KSFj7OuYGx37qLIQjmM1mhgwZwoABA7j44ospKSlp1e28/fbb3HPPPb+6PC8vj6lTpzJ48GD69evHhRdeeNrbOXz4MAMGDDjj/Z249dtZZ53VssBCCCGapbS6ngarNqZA72iq6hr4yze76R8XwqwRSUbH+RWTSfGnaf05VlXH80v3Gh1HCIc7WlrNaz8e4KKBsVw2PMHoOKKZfLxMXDQolvdvHU3aQ6ncOr4rGzOOccNb60j9Rxqvba6maOTD8NudMP1125Zs3z7CmNU3wzcPQ0G60Q9BiOP8/f3ZsmULO3bsIDw8nFdeecWht//HP/6R8847j61bt7Jr1y6ee+45h9zuiQX6qlWrHHK7QgghfqnAvgd6ZJDBBbrWOq2974H+nx8OcLS0hqcu6e+23aL7x4Vy3eguvLcmg51HSo2OI4RD/X3xXqxWeOyCPkZHEa2UHBnI4xf0ZdXj5/DiVUOJDfXjuW/3MObZ5dz38S7WBJ+Hvm053LqcwshRtn3VXxkB706DPV+D1WL0QxDiuDFjxpCTkwPAgQMHOP/88xk+fDjjx49nz549AHz55ZeMGjWKcePGMWnSJPLy8k57m0ePHiUh4X8fQA4aNAiwLbF7+OGHGTBgAAMHDmTBggW/OvfEUfmpU6eSlpbGY489RnV1NUOGDOGaa64BICgo6LS3m5aWxoUXXsjll19Onz59uOaaa9Cy+4IQQpxRYbmtQHfGCHpL9kFv9zKKKpmz4iDTh8aTkhxudJzTemByb77adpQ/fr6Tj28f06aGcUK4i61ZJXy2OYc7JnYnMTzA6DiijXy9zFwyOI5LBsexP7+ceWsy+WxTNl9sPUL3qECuHtWFmO6/Yep1b8Cmd2zd3+dfDaGJkHIzDLseAmWJQ4f27WOQu92xt9l5IFzQvBFri8XCsmXLuOWWWwCYPXs2r732Gj179mTt2rXcddddLF++nHHjxrFmzRoqKipYsGABf/vb3/jnP/95ytu9++67mTlzJi+//DKTJk3ipptuIi4ujs8++4wtW7awdetWCgsLGTFiBBMmTGhW1ueee46XX36ZLVu2/Oq6093utm3b2LlzJ3FxcYwdO5aff/6ZcePGNes+hRCio2o6gp7t4NuWAr2JP3+1G2+z8oiRu1B/bx6ThnGiHdFa8+evdhEZ5MPdZ3c3Oo5wsB7RwTx5SX8ePb8PX207wvtrM/nzV7vwNsGyYznMGnETI8fej9r7Daz7Lyx7CtKegwEzYORtED/c6IcgOpDGkeicnBz69u3LeeedR0VFBatWreKKK644flxtre0NWnZ2NjNnziQnJ4eGhga6du162tufMmUKBw8eZPHixXz77bcMHTqUHTt2sHLlSq666irMZjMxMTFMnDiR9evXHx9hb61T3W5ISAjDhw8/Ppo/ZMgQDh8+LAW6EEKcQUGTEXQp0J0kbW8+3+/O47EL+hAT4l6N4U7lsmEJfLguk+e+3cPkfp0JDfA2OpIQrfbN9lw2ZBzjL9MHEuwn/5bbK38fM1ekJHJFSiK7jpTxj4Wr+X5XHgs359AtMpCZIwYw47JPiao+COvfgK3zYeuHEDfMVqj3nwHenvEaLRygmSPdjta4Br2qqoopU6bwyiuvcOONNxIWFnbSEep7772XBx54gLPPPpuNGzfy5JNPnvE+wsPDufrqq7n66quZOnUqK1asaFY2Ly8vrFbr8Z9ramqa+7BOysfnfzvVmM1mGhoa2nR7QgjRERRU1OJjNhHi5/hyWprEYdvS6U9f7qJrZCA3jU02Ok6z2RrGDZCGccLj1dRbePbb3fTpHMzMETIbpKPoFxfC9f19Wfv7c/nHFYMJD/Th2W/3MObZZdy2uJIlyQ9Td/9OuODvUFcBi+6E5/vC0ifgWIbR8UUHEBAQwIsvvsg///lPAgIC6Nq1Kx9//DFgm/WzdetWAEpLS4mPjwfgnXfeOePtLl++nKoq2w4G5eXlHDhwgKSkJMaPH8+CBQuwWCwUFBSwYsUKRo4c+Ytzk5OT2bJlC1arlaysLNatW3f8Om9vb+rrf73DS3NuVwghRPMVlNu2WFPK8cuMZQQdmPvzIQ4WVjL3phH4epmNjtMiA+JDudbeMO7KEYn0jws1OpIQLTb358NkH6tm3i2j3LY5Y3MppczABiBHaz1VKXUO8A/AB9gI3KK1liGqJgJ8vLh8eAKXD09gf345H2/I5rPNOSzdlUd4oA/ThozlskuvpH/dFtS6/8KqF+Hnf0Ov822j6rKnunCioUOHMmjQID788EPef/997rzzTp5++mnq6+uZNWsWgwcP5sknn+SKK64gNDSUSZMmcejQodPe5saNG7nnnnuOj4bfeuutjBgxgpSUFFavXs3gwYNRSvG3v/2Nzp07c/jw4ePnjh07lq5du9KvXz/69u3LsGHDjl83e/ZsBg0axLBhw3j//fePXz59+vST3m5jkzshhBAtU1hRR2SQz5kPbIUOX6Dnl9Xw4rJ9TOobzdm9o42O0yoPntebr6VhnPBQBeW1vPLDfs7tE824nu2iIdj9wG4gRCllAt4BztVapyul/gTcALxpZEB31iM6mMcv7MvDU3rz075CPtmYzftrMpn782G6RQVy6ZAnmTH6CRIOLLA1lpv3LYR3hxG3wpCrwT/M6Icg2oGKiopf/Pzll18e/37x4sW/On7atGlMmzaN8vJygoODj19+4403cuONN/7q+IcffpiHH374V5crpfj73//O3//+919cnpyczI4dO44f07T4buqvf/0rf/3rX3/1OE51u6mpqQwf/r/+Di+//PJJb1cIIcQvFZTXEh/mnCV3HX7I4blv91Bv0fzfRf2MjtJqoQG2hnEbM47x6SZHtykQwrmeX5pOTb2F313U1+gobaaUSgAuAt6wXxQB1GmtGzf5XgpcZkQ2T+NlNnF2n2heuWYY638/iWdnDCQqyJfnl6Yz7rV9TNtzDm+O+IqiKS9DQAQsedw2/f3L30DeTqPjCyGEEKIdK6yodcoWa9DBR9A3ZhTz2eYc7j67O8mRgUbHaZNfNIzr35lQf2myJdzfntwyFqzP5PoxyXSPCjI6jiO8ADwCNA6hFQJeSqkUrfUG4HLgpIvslVKzgdkAMTExpKWltfjOKyoqWnWekZqbORa4szdcmeTP2twG1h4t48+LS/gz4XQLfYBpnTO4pOE7kja/j3njXEpCB5ATfyGFkaPQJsf+V9een2d3EBoaSnl5ORaLhfLycqPjtEh7zVxTU+Mx/36EEMLZLFZNUUUtkUFSoDuUxap54ouddA7x467UHkbHabPGhnGXvLyS57/by1PTBhgdSYjT0lrz9Fe7Cfbz5jeTehodp82UUlOBfK31RqVUKoDWWiulZgH/Ukr5At8BlpOdr7WeA8wBSElJ0ampqS3OkJaWRmvOM1JrMjdOQThcWMm3O3L5ZvtR/nU4kX9xCyOib+aeTmsZU7yQ/rv+BsFxtj3Vh98IQVGGZTaaJ2XevXs3QUFBVFRU/GK6uCc4cYq7JzhTZq01fn5+DB06tE33o5Q6H/g3YAbe0Fo/d8L1DwC3Ag1AAXCz1jrDft0NwP/ZD31aa33mTnxCCOEkxZV1WDUygu5oC9ZnsSOnjBevGkqgb/t4GqRhnPAky/fks3J/IX+c2o+wAOc02XCxscAlSqkLAT9sa9Dnaa2vBcYDKKUmA70MzNiuJEcGcmdqd+5M7U5mURXf7crlu1153JQ+GvRIZgTt4na+p+cPT6NX/A3VfwaMmi17qrs5Pz8/ioqKfrH9lzCG1pqioiL8/Nq2ztLePPMV4DwgG1ivlPpCa72ryWGbgRStdZVS6k7gb8BMpVQ48ASQAmhgo/3cY20K1QylVfXUW61OGyUTQnimwgrbHugygu5ApVX1/H3JHkZ2DefiQbFGx3GoxoZxT325i49uH2N0HCFOqt5i5ZlvdtMtMpDrxnQxOo5DaK0fBx4HsI+gP6S1vlYpFa21zrePoD8KPGNcyvYrKSKAW8d349bx3SiurGPZ7jyW7opl2v7BxNZncqP391yx/XP8ts2ntvNwfMfeBX0vAS8pAt1NQkIC2dnZlJSUtLkwdLWampp2l9nPz4+EhIS23s1IYL/W+iCAUmo+MA04XqBrrX9ocvwa4Fr791OApVrrYvu5S4HzgQ/bGupU6i1W3ll1mH9/vw9fbzOLfzNeinQhxHEF5bYCXUbQHejF5fsora7nyYv7O2XvOiOFBnhzzzk9eOrLXWzMKGZ4l3CjIwnxK/PWZHCwoJI3rk/B29zue1U+bJ/+bgJe1VovNzpQexce6MMVKYlckZJIbYOFtQeLWb5nLJfuPsyosiXccGQJ3T69hXLvSIr7XkvsuXfhExpjdGxh5+3tTdeuXUlLS2vztGpXk8ynFA9kNfk5Gxh1muNvAb49zbnxJzuprb08KioqePmT73l/dx1HKzX9IkykH2vg5td/4LfDnLPfsSN4Uo+JRpLZNSSzc/ycUw/AgZ1bqDxscnjmDlegl1TV8cHaTKYPTaBfXIjRcZxi5ohE/r1sH6//eJA510uBLtxLSVUdL3y/j7E9Iji3r2dubXgmWus0IM3+/cPAr/dTEi7h62VmQq8oJvSKQl/cj4OFE1m++z4+3fYto/I/ZsK2F6jb+jI/B0+ibMitDBkxjthQf6NjC9FhKaWuxTadfWJLz21LL4+s4irue3sFm/Nr6RIRwJuX9+OcPtG8uzqDJ77YSYZPMjeO7drSSC7hST0mGklm15DMzrH3xwOwfQ9TJ00gyNfL4Zk7XIH+/tpMqustzJ7QzegoThPg48V1o7vw8g/7OVhQQbf20R1btBMvLd9PeU09/3dRP7cdjRDtk1KK7lFBdI/qARPupbL2TlZtXo9p/esMK/oG/5WLWfVjP14PmUHwoKlM6hfLwPhQTCb5dypEG+Xwyx0sEuyX/YJSahLwe2Ci1rq2ybmpJ5yb5uiARZV17C6y8Mj5vbllXFd8vcwAXD+mCz+mF/CXb/cwqlsEfWPb5+COEKL5Citq8fM2Eehjdsrtt/u5pU3VNliY+/NhJvaKondnz+qy2lLXj0nG22zivz8dMjqKEMc1zmC5dGi8vMkRhgv09eKs0WMYfe/b+D2yl4LRv2dgQDFPVj7NjJ8v5ePXnmTCX77h8c+28cOefOoarEZHFsJTrQd6KqW6KqV8gFnAF00PUEoNBV4HLtFa5ze5agkwWSnVSSnVCZhsv8yhhiSG8a+zA7grtcfx4tyei79fPohQf2/u+3Az1XUn3YhDCNGBFJTb9kB31kBThyrQP998hMKK2nY9et4oKtiXy4Yl8Omm7OONDIQw2gfrbDNYbhvf/n8HhWdRAZ2IOv8Rgh/ZCZe/RWJ8HE97z2Wx9Q66bn2eR97+jpSnl/LgR1vZkt8gxboQLaC1bgDuwVZY7wY+0lrvVEr9SSl1if2wvwNBwMdKqS1KqS/s5xYDf8ZW5K8H/tTYMM7R/L1O/mY7IsiXf14xmH35FTzzza6THiOE6DgKKmqJcmLjyA5ToFutmjk/HaRfbAhndY8wOo5L3Da+6/FOpEIYrd5i5d1VGYztIVMEhRsze8GAy/CavRxuXkJQ74ncphaxNuA3zAl7h327NvLCplqGP72Uxz/bxobDxWitjU4thNvTWn+jte6lte6utX7GftkftdaNhfgkrXWM1nqI/euSJue+pbXuYf+aa0T+Cb2iuG18V+atyeSnfQVGRBBCuInC8jqn7uzQYQr0H9ML2J9fwewJ3TrMutduUUFM7hfDe2syqKxtMDqO6OC+2X6U3LIabhnnnk12hPgFpSBpNMych7pvE6bhNzC6Yjlf8FuWRT7PbV3yWLT5CJe/tpqz/5HGi8v2kX2syujUQggnemhKb2JCfHlrpSwfFKIjK6ioddoWa9CBCvT//nSQ2FA/Lmpn+56fyewJ3SmtruejDVlnPlgIJ9Fa88ZPh+gWFUhqr/bZuV20Y+Hd4KJ/wm93wMTHSKrZy30Z97Kjy/PMG19MbIgfzy9NZ/zffuDWdzbw074CGVUXoh3y9TJzZUoiP6YXcKSk2ug4QggD1FusHKuSEfQ225FTyqoDRdw0Nrkj7Ln8C8O7dCKlSyfeXHmIBousmRTGWH/4GNtzSrl5bFfpiC08V2AknP04q8e8CRf8HXP5Ecatv4cPLQ+ycdox7pmYzObMY1z35jrOff5H3ll1WGYvCdHOXJmSiAYZ+BCigyqurENrZAS9rf7700GCfL2YNTLJ6CiGuH1id7KPVfPNjlyjo4gO6o2fDhIW4M1lwxKMjiJEm1nNvjBqNty3GS59DbSFiCV38+Deq1lzfjYvXNGXED9vnvhiJ2P/upx/f7+P0qp6o2MLIRwgMTyAcT0i+Wh9FharzJQRoqNpbL4tI+htkFNSzVfbjnLVyERC/LyNjmOIc/tE0z0qkNd/PCDTLoXLZRRVsnR3HteMSsLfSftFCmEIszcMuQruXA2zPgD/Tnh//RsuXXEJi0bsYuHsYaR06cS/vk9n7F+X89fFeyiskF01hPB0V41M4khpDSvSpVmcEB1Ngf3/cRlBb4O5Kw+hgJvGdtzGVCaT4rbx3dh5pIxVB4qMjiM6mLk/H8bLpLh+TLLRUYRwDpMJ+lwEt/0A13wKwbHwzUMMXXg2b/TZxLd3jWBi7yhe+/EA4//6A88vTZep70J4sEl9Y4gM8uHDdZlGRxFCuFihfQRdtllrpdLqej5cl8nUQbHEhfkbHcdQlw6NJzLIl9dXHDQ6iuhAGhsUXjwojpgQP6PjCOFcSkHPSXDLd3D959CpK3z7CH0/SeWVnptZet8YzukTzYvL9jHx72m8vzZDeoMI4YF8vExcNjyBZXvyyS+rMTqOEMKFGkfQI4N9nHYf7bpAn78uk8o6C7eO72Z0FMP5eZu5aWwyK9IL2H20zOg4ooNYsD6TqjoLN8vWaqIjUQq6pcJN39gK9ZB4+PoBesyfwCt9trPwjpF0jQzg9wt3MOWFFaTtzTc6sRCihWaNSMJi1Xy8MdvoKEIIFyooryXI14sAHy+n3Ue7LdDrGqzM/fkwY3tEMCA+1Og4buHaUV0I8DHzXxlFFy7QYLHy9s+HGdU1XH4HRcfUWKjf8h1c+ykERsGX9zH0ywv4aHw+c64dhtZw49z13P3BJhmJE8KDdI0MZHS3cOavz8QqzeKE6DAKK+qIDHLe6Dm04wL9q21HyC2r4TYZPT8uNMCbWSOS+GLrEYqqZVqlcK5vd+RypLRGZrAIoRT0mAS3Lbc1kzOZUR/fwORVV7F4mpUHz+vF0l15nPvPH3lv9WHpDC2Eh7hqZBJZxdXS30eIDqSgvMapDeKgnRboWmvmrDhIr5ggJvaKMjqOW7l5XDIa+C5DtvwRzqO15o2Vh0iOCODcPtFGxxHCPShlayZ35yqY9h+oKMDn/ence+QRll8bxeDEMP7w+U4ue3UV+/MrjE4rhDiDKf07ExbgLc3ihOhAbCPoUqC32Mr9hezJLefW8d1QShkdx60kdArg4kGx/JjVQGm1FOnCOTZlHmNrVgk3j+uKySS/g0L8gskMQ6+BezfC5GcgZxMJC87jvah5vDotnoyiSqa+9BPvrj4sW2MK4cb8vM3MGJrAd7tyKamqMzqOEMIFCsprZQS9NeasOEhUsC/ThsQZHcUtzZ7QnRoLfLBWPvEVzvHmykOE+Hlx2bAEo6O4nFLKrJTarJT6yv7zuUqpTUqpLUqplUqpHkZnFG7C2w/Ougfu2wyj7kBt/ZALll/IT6M3MD45iD9+vpMb566XtelCuLHpQ+Opt2i+3ZFrdBQhhJPVNlgora6XEfSW2n20jJ/2FXLjWcn4epmNjuOW+sWF0D/CxNyfD1HbYDE6jmhnsoqrWLwjl6tGJRHo67wOl27sfmB3k59fBa7RWg8BPgD+z4hQwo0FhMP5z8Lda6HHOQSt+itzyu/i7dG5rD1UyJQXVrBkp7z5F8IdDYgPoWtkIF9sOWJ0FCGEkxVV2GbKyAh6C/33p4ME+Ji5ZlSS0VHc2vnJ3uSX1/Ldzjyjo4h25u1VhzEpxY1nJRsdxeWUUgnARcAbTS7WQIj9+1BA3sWJk4voDjPnwQ1fonyCSN3yAJuSX2N0SBG3v7eRv3yzW/ZNF8LNKKW4eHAcaw4VkSezXUQL1Vus5JfXsCe3jFUHCsktlX9D7qyg3L4HupNH0NvV8FZhRS1fbj3CNaO6EBbg3Pb3nq5/pJn4MH8WrM/i4sGyFEA4RnlNPQvWZ3HhwFhiQ/2NjmOEF4BHgOAml90KfKOUqgbKgNEnO1EpNRuYDRATE0NaWlqL77yioqJV5xlJMp+c6vM0cSHf0PXQh7xiXcni8It4cMWl/Lj9MHcO8SXMt2Wfr8vz7BqSuWO6ZHAcLy7bx1fbjnLLuK5GxxEeYHPmMW59ZwNFlb/sXTAgPoSv7h1vUCpxJjkl1QDEhvo59X7aVYG+cFMO9RYto+fNYFKKmSMSeH5pOplFVSRFBBgdSbQDH23IpqK2gVvHd7w3KEqpqUC+1nqjUiq1yVW/BS7UWq9VSj0MPI+taP8FrfUcYA5ASkqKTk1NPfGQM0pLS6M15xlJMp/OuVDxGHz/JBdumcfE8I3cX34df9kwgv9cM4SU5PBm35I8z64hmTumHtFB9IsN4cutR6RAF80yb00mtQ1WfjOpJxGBPoQH+rIho5i5Px/mUGElXSMDjY4oTmJPbjkmZfudd6Z2M8Vda82CDVkMSwqjZ0zwmU8QXJGSgEnBRxuyjI4i2gGLVTP350OMSO7EoIQwo+MYYSxwiVLqMDAfOEcp9TUwWGu91n7MAuAsg/IJTxQUBZe+Ajd+Q2BAIG+Yn+NZ6wvcPWcx89ZkGJ1OCGF3yZA4tmSVkFlUZXQU4eaq6yws2ZnLhQM785tJvbhuTDIXDYrltvHdAPhm+1GDE4pTSc8tJzkiED9v5/Y5azcF+qbMY+zPr2DWCBk9b67YUH9Se0fz8cYsWdco2uynfQVkH6vmxrM65uiB1vpxrXWC1joZmAUsB6YBoUqpXvbDzuOXDeSEaJ7ksXDHSkj9HeewluV+D7Ply1f485c7sVhlKzYhjDZ1UCwAX26TNiPi9L7fnUdFbQOXDo3/xeVxYf4MSwrjq21SoLurvXnl9HLBQHC7KdDnr8si0MfMRfYXSNE8M0ckkldWS9reAqOjCA/30YYswgN9OK9fjNFR3IbWugG4DfhUKbUVuA542NhUwmN5+ULqo6g7VxGQMJB/eL/OmHV388jc76isbTA6nRAdWkKnAIZ36STd3MUZLdqcQ+cQP0Z3jfjVdRcNimP30TIOFlQYkEycTk29hcNFlfTuLAV6s5TX1PPVtqNcPDiuo27r1Grn9IkmKtiX+etlmrtoveLKOpbuyuPSIfH4eLWLl5U20Vqnaa2n2r9fqLUeqLUerLVO1VofNDqf8HCRPVE3fgNTniXVexd/yLyJV158llx78xohhDEuGRzH3rxy9uaWGx1FuKmiilp+TC9g2pA4TCb1q+svHNgZkGnu7mh/fgVa4x4FulLKTym1Tim1VSm1Uyn1lNNTtdBX245SXW9h5ohEo6N4HG+zicuHJ/DD3nzZHkS02sLNtgaN8jsohIuYTDDmLrzuWoWK6sUjlf9g978v5UBGptHJhOiwLhwYi0nBF1tzjI4i3NTX24/SYNW/mt7eKDbUn5QunWSauxvaY//gzV2muNcC52itBwNDgPOVUifdJsgo89dn0TsmmCGJYUZH8UgzUxKxWDWfbMw2OorwQFprPt6QxeCEUJd8qiiEaCKyB6F3LSNv1O8YpzcQNHci+9d9a3QqITqkqGBfxvaI5MutR9FaekOIX1u0OYc+nYPpGxtyymMuHBjLntxy9ufLNHd3kp5Xjo+XiWQX7Hx1xgJd2zT+C/G2f7nNq86e3DK2ZpVw5YhElPr1VBFxZsmRgYzpFsGC9VlYpdmQaKFt2aXsyS3nShk9F8IYJjMxFzxK4cyvqVN+dPv6KjI/+R1YZF26EK528eA4Mour2JJVYnQU4WYyiirZlFlyytHzRhcOtPXTkmnu7mVPbjk9ooLwMjt/KWezFmwrpczARqAH8EqTLYOaHjMbmA0QExNDWlpai4JUVFS0+ByA93fX4qUguuowaWmu33KmtbmNdmLuQUENrD5Yy2sLl9MvwrlbB7RFe3m+PUFzM7+zsxYfE3QqO0ha2iHnBzsDT3yuhXCE2L6jKbh7JUvnzGbKjlc4duRnOl33LnTqYnQ0ITqMKf07838Ld/D5liMMTepkdBzhRhZtPoJStl4Fp9M51I8RyZ34ZvtR7ju3p4vSiTNJzy3nrO6/buznDM0q0LXWFmCIUioMWKiUGqC13nHCMXOAOQApKSk6NTW1RUHS0tJo6Tk19RZ+s2IZ5w+M5eLJw1p0rqO0Jrc7ODH36HoL8/ctY3ddOHelDjUu2Bm0l+fbEzQnc3WdhXt/+J6pg+O58LwhLsl1Jp74XAvhKFGREYz+zXyef/3v3Fb0IrX/GY/vzLmA+37wKkR7EurvzaR+0Xyx9Qi/u7CvNE4VgG054KItOYzqGk5cmP8Zj79oYCxPfrmL/fnl9IiW5YNGK62qJ7eshl4uWsrZolcNrXUJ8ANwvlPStNB3u/IoqaqXxlQO4OdtZvrQeJbsyOVYZZ3RcYSHWLzzKOW1DVyRIr+DQriL0ABv7rj7EZ6M/Q+HakPQ8y4jKeNjsFqNjiZEh3DF8ESKK+tYviff6CjCTWzNLuVQYSXTzzC9vdEFA2NRCr7eluvkZKI59ubZGsT1dkGDOGheF/co+8g5Sil/4Dxgj5NzNctH67OID/NnbPdIo6O0CzNHJFJnsbJws3QfFc2zYH0WXSICGN0t3OgoQogmAny8eOaWafwj6RW+sIyh26F58NF1UFNmdDQh2r3xPSOJCvaV5rviuEWbc/DxMnH+gNhmHR8T4seI5HC+3n7EyclEcxwv0N1oBD0W+EEptQ1YDyzVWn/l3FhnllVcxcr9hcwckXjSfQRFy/WNDWFwYhjz12dK91FxRhlFlaw5WMyVKdKgUQh35Odt5uUbxvFZ8pM8VX8d1r3fwn/PhqIDRkcTol3zMpuYMTSeH/bmU1Bea3QcYTCtNd9sP8q5faIJ9fdu9nkXDYwlPa+CffbiUBgnPbecYD8vYkP9XHJ/zenivk1rPVRrPUhrPUBr/SdXBDuTjzZkYVJw+fAEo6O0K1eNSCQ9r4LN0n1UnMHHG7IxKbhsmPwOCuGu/LzNvH59Chs7TWVWze+oKS+CN86FjFVGRxOiXbt8eAIWq+bzLTIrsaM7WlpDfnltixuMndMnGoC1h4qdEUu0wN7ccnrHBLtsQMojO1dYrJqPN2QzoVdUsxotiOabOjiOAB8zC9ZlGR1FuDGLVfPJxmwm9oqis4s+TRRCtI6ft5l7hvoS2GsCk8v/SJkpDN6dBlsXGB1NiHarZ0wwgxPD+HhDtsxK7OC2ZZcCMDAhrEXnJXTyJ8jXS0bQDaa1Zm9eucsaxIGHFugr0gvILathljSHc7ggXy8uHhTHl9uOUFEre+iKk1uxz/Y7eKU0hxPCI/iYFa9dN5yk7v2ZUPw4ReFDYOFsSHsOpHgQwimuGJ7A3rxyduRI74eObHtOCV4mRZ8WFnhKKXpEB7Evv8JJyURz5JXVUlpd77IGceChBfr89ZlEBvlwTp8Yo6O0S7NGJlJVZ+HLrdKYQpzcxxuyCA/04dy+8jsohKfw9TIz5/rhdEtMYPyRe8ntOgPSnoVFd4FFPpAVwtEuHhSHj5eJTzbKrMSObFt2Kb07B+Pn3fLtLntGB5GeJwW6kVzdIA48sEAvKK9l2e58ZgxLkL0lnWRIYhi9Y4KZv17+QxG/VlRRy9JdeUwfGi+/g0J4mAAfL+beNJIu0Z1I3X8FOUN+A1s/gI9vgAZpZiWEI4UGeDOlf2c+33qE2gaL0XGEAbTWbM8pZVBCaKvO7xUTTGFFrWyBbKD0XNdusQYeWKB/timbBquWqbVOpJRi5ohEtmaVsPuoTMsSv7RoyxHqLZqZssRECI8U6u/Ne7eMJC40gPM3n8XRMU/Anq/gg5lQV2l0PCHalcuHJ1BSVc+y3bInekeUVVxNSVU9A+PDWnV+z5ggAJnmbqA9ueVEB/vSKdDHZffpUQW61poF67MYkdyJHtFBRsdp16YPjcfHbGKBjKKLJrTWfLQ+iyGJYfRy4SeJQgjHigzyZd6towjx9+bi9QMpPPd5OPQjvDcDqkuMjifaIaXU+UqpvUqp/Uqpx05y/QSl1CalVINS6vITrrMopbbYv75wXeq2G9cjks4hfrInege1LacEoNUj6D3t77XSpVGcYdLzyl06vR08rEDfkHGMg4WVMnruAp0CfTh/QGc+25RNTb1MyxI227JL2ZtXLr+Dp6GUMiulNiulvrL//FOTN5ZHlFKLDI4oBABxYf68e8tIGqyay9d0o3zqHMjZCO9Mhcoio+OJdkQpZQZeAS4A+gFXKaX6nXBYJnAj8MFJbqJaaz3E/nWJU8M6mNmkmDEsnrS9+eSW1hgdR7jY9uxSfMymVg9qxIX6SSd3A1msmvS8cpcPSnlUgT5/XRZBvl5cNCjW6CgdwqwRiZTVNLB4R67RUYSbWLAhCz9vExcPlt/B07gf2N34g9Z6fOMbS2A18JlRwYQ4UfeoIN68YQRHS2u4dk0cNVe8D4X74L1LZSRdONJIYL/W+qDWug6YD0xreoDW+rDWehtgNSKgM101MgmlFG/9fMjoKMLFtmWX0jc2uNU9e6STu7Eyi6uobbC6fATdy6X31gZlNfV8vf0IM4YlEODjMbE92uhuESR08ufTTdlcOjTe6DjCYNV1Fr7ccoQLB8YS7OdtdBy3pJRKAC4CngEeOOG6EOAc4CYDoglxSsO7dOKlq4Zyx7yN3LU2mv9e8S7mBdfA+5fDdQvBV5aziDaLB5qumcsGRrXgfD+l1AagAXhOa73oZAcppWYDswFiYmJIS0trUciKiooWn9NcI2JMvPvzQQZ75xLorRx6287M7SwdIbNVa7ZkVjEm1qtNjzXYWsvWLEurbqMjPM/OtDHPtsNJRU46aRUHTnmcozN7TKX79baj1NRbmSlTa13GZFJMHxrPKz/sJ6+shpgQP6MjCQN9u+Mo5bUN8jt4ei8AjwAnq2guBZZpraXzonA7k/t35s+XDuD3C3fw++BEnr38LdTHN8IHs+Caj8EnwOiIomProrXOUUp1A5YrpbZrrX/1bllrPQeYA5CSkqJTU1NbdCdpaWm09JzmiuldxgX//omDpgTuTe3p0Nt2Zm5n6QiZDxZUUL3kR84f2Y/UNjTW3Wc6yE/f7GbwiLNa3KisIzzPzrT1+30olc6sCyaedoDY0Zk9pkBfuCmH7lGBrW6yIFpn+tB4Xlq+n8+35DB7Qnej4wgDLVifRXJEACO7hhsdxS0ppaYC+VrrjUqp1JMcchXwxmnOb9PID7jXp87NJZldozmZ44GLu3szf30W9SV+3NLnN/Td/TzHXr2A7QP/D21y7cyZ9vo8uxsXZc4BmlYoCfbLmkVrnWP/86BSKg0YCpx6OMsN9Y0N4Zw+0cxddZhbx3fD36fle2ILz7I9pxSAgW2sXXo06eQu78FcKz2vnKTwAJfP3vaIAj2ruIp1h4t5eEpvlHLstCBxet2ighiSGMZnm6RA78gOF1ay9pD8Dp7BWOASpdSFgB8QopSap7W+VikViW0N5vRTndzWkR9wr0+dm0syu0ZzM0+cqPH6aCufbs7hnKtvo1/ProR/cQ8T89+GK98Fk+uKivb8PLsTF2VeD/RUSnXFVpjPAq5uzolKqU5Alda61v5aOhb4m9OSOtGdqd254rXVLFifyY1juxodRzjZtuxSfL1M9GzjzlO9mnRylwLddbTWbM0uoW9siMvv2yOaxC3abPuQddqQOIOTdEwzhsWzJ7dc9kTvwD7blI1JwWXDEoyO4ra01o9rrRO01snY3nwu11pfa7/6cuArrbW08BVuTSnFc5cNJKVLJx74aAubI6fC+X+17ZO++DHQ2uiIwgNprRuAe4Al2JpofqS13qmU+pNS6hIApdQIpVQ2cAXwulJqp/30vsAGpdRW4Adsa9B3uf5RtN2I5HBSunTivz8dot7S7nrhiRNszy6lf1wIXua2lVtxoX4E+pjZL43iXGr1wSKyj1Vzfv/OLr9vty/QtdYs3JzDqK7hJHSSNXBGmDooDi+TYuHmZs9GE+2I1pqFW3IY2yOSzqHSh6CVZgEfGh1CiObw9TLz+nXDiQnx47Z3N5Ld+3oYcw+smwNrXjU6nvBQWutvtNa9tNbdtdbP2C/7o9b6C/v36+0fcgZqrSO01v3tl6/SWg/UWg+2//mmkY+jre46uzs5JdV8seWI0VGEE1msmh1HShmUENbm21JK0SMmWPZCd7H312YS6u9tyO5hbl+gb80u5WBhJTOGSRdxo4QH+pDaO5pFm3OwWGX0pKPZmHGMrOJqpksn/2bTWqdprac2+TlVa73YyExCtEREkC9v3ZhCbYOFW9/ZQPmEP0Lfi2HJ72D3V0bHE8Jjnd07mt4xwbz24wGs8p6q3TpYUEFVnYWB8Y7pndUrOoj0PBlBd5X88hqW7Mjl8uEJ+Hm7vl+E2xfoCzdl4+tl4oKBsu+ykWYMiye/vJaf9xcaHUW42Gebc/D3NjPFgCk+Qgjj9IgO5j/XDGNffgX3zd+K5dLXIX4YfHorZG80Op4QHkkpxZ2p3dmXX8GyPflGxxFOsi3b1iDOUc2te8UEU1hRy7HKOofcnji9jzdk02DVXD0qyZD7d+sCvd5i5cttR5nUL4YQ2XfZUOf0iSbYz0umuXcwtQ0Wvt52lCn9Ywj09YiekkIIBxrfM4onL+nPD3sL+McPWXDVfAiKhg9nwrEMo+MJ4ZGmDoolMdyf55emy1r0dmp7TikBPma6RbWtQVyjpp3chXNZrJoP1mZyVvcIujvo76+l3LpA/3FvAcWVdcyQqbWG8/M2M3VQLIt35FJZ22B0HOEiP+wpoLS6nunSHE6IDuu60V24elQSr6Yd4IsDDXDNJ2CpgwXXQH210fGE8DheZhO/v7Afu4+W8fqPHrVbnGimbdklDIgPxWxyzM43jZ3c9+XLOnRnW5FeQE5JNdeM6mJYBrcu0BduziEi0IcJvaKMjiKAGcMSqK63sGRnrtFRhIss3JxNVLAvY7tHGB1FCGGgJy/uz4jkTjzyyVZ21MXAjP9C7nb46gHp7C5EK5w/oDMXDYrlxWX7pflXO9NgsbLzSBmDHLT+HP7XyX2frEN3uvfXZhAZ5Mt5/WIMy+C2BXppdT1Ld+dx8eA4vNu4PYFwjJQunUgM95dp7h1ERZ3mhz0FXDI4rs1bhAghPJuPl4n/XDOcTgE+3P7eRgrjUmHio7D1A9g41+h4Qnikpy7pT5CfFw9/sk2a8LYj+/IrqG2wMtBB689BOrm7Sk5JNcv35DNzRAI+Xsa993Xbd93fbj9KXYNVOke7EaUU04fE8/P+QvLKZDvn9m59bgN1FvkdFELYRAX7Mue6FAorarnr/U3Uj3sYekyCbx+VpnFCtEJkkC9PXtKfrVklvLXykNFxhINsP94gLsyht9srOkjWoDvZ/HWZaGDWCGOawzVy2wL9s805dIsKdFj3Q+EY04clYNXw+RYZRW/vVh9toGd0EP3jQoyOIoRwEwMTQvnb5YNYd6iYp7/Za5vqHtwZProeKmWXDyFa6uJBsZzXL4Z/fLeXQ4WVRscRDrDraBkBPma6hAc49HZ7xgRRUF5LSZV0cneGeouV+euzOLt3NIkO/rtrKbcs0LOKq1h3qJgZQ+NRyjHNFYRjdI0MZEhiGJ9tkgK9PcsqriL9mJXpw+R3UAjxS9OGxHPruK68szqDRXur4cr3oLIAPrkZrBaj4wnhUZRSPH3pAHy9TDz6yTbZG70dOFBQQfeoIEwOahDXqKe9UZzsh+4cX249QkF5LdcYtLVaU25ZoDeOzk4bIlNr3dGMYfHsyS1n15Eyo6MIJ2nsM3Cp/A4KIU7i0Qv6MDI5nMc+28YeUze46B9w6EdY9aLR0YTwODEhfvxhaj/WHS7mucV70NJ40aMdLKike1Sgw29XOrk7z/78Cv74+U4GJ4SS2jva6DjuV6Brrflscw4ju4YbPr1AnNzUQXF4mRQLN2cbHUU4gdaaRZtz6BNuIi7M3+g4Qgg35G028fLVQwn28+aO9zZS1ncW9LsUlj8NRzYbHU8Ij3P58ASuG92FOSsO8vzSdKPjiFaqqmsgp6TaKftnSyd356iobeD29zbg62Xi1WuHO2xrvLZwuwJ9W3YpBwsqZe9zNxYe6ENq72g+33JEuo62Q1uzSzlYWMlZcV5GRxFCuLHoED/+c80wso9V8+DH27Be9C8IjIZPb4O6KqPjCeFRlFI8dUl/Zo1I5KXl+3lx2T6jI4lWOFhg6yPQPdrxBbp0cnc8rTUPfbSVw0VVvHT1ULcZmHK7An3h5hx8vExcMDDW6CjiNC4bFk9+eS0/75emQO3Nwk3Z+HqZSImRAl0IcXojksN5/MK+LN2Vx2vri2H6a1C0H777vdHRhPA4JpPiL9MHctmwBJ5fms5/0vYbHUm00IEC2+i2M0bQQTq5O9qrPx5g8c5cHr+gD2d1jzQ6znFuVaDXW6x8ufUIk/pGE+rvbXQccRrn9I0mxM9L9kRvZ+otVr7cdpRJ/WII8DZ+io8Qwv3dPDaZqYNi+ceSvazWA+Cse2DDW7D3W6OjCeFxTCbF3y4fxLQhcfxt8V5e//GArEn3IAcKKjEp6BLhnGW6SeEBFJTXUlMvDTnbakV6Af9Yspepg2K5ZVxXo+P8glsV6CvSCyiqrGP60ASjo4gz8PUyc9GgOBbvyKWytsHoOMJBVqQXUFxZJ0tMhBDNppTir5cNIjkykPvmb6ZgxCPQeSB8fg9U5BsdTwiPYzYp/nnFYC4aFMuz3+7h/vlbqJD3Wh7hQEEFieEB+HmbnXL7jVOwj5bWOOX2O4qSqjrun7+ZntHB/O3yQW63Y5FbFeifbc6hU4A3E3tFGR1FNMOMYfFU11tYsjPX6CjCQRZuziE80IcJ8jsohGiBQF8vXrl6GGXV9fz2091Ypv8X6irgi/tARv+EaDEvs4mXZg3locm9+GrbES5+aSU7j5QaHUucwYH8Cno4aXo7QHwnW4Gec6zaaffREbyadoCS6npemDWEAB/3W9LpNgV6Vb1m6a48Lh4ch4+X28QSp5HSpROJ4f6yJ3o7UVZTb/sdHBSLt1l+B4UQLdM3NoQ/TevPyv2FvLzdC875A6R/Czs+NTqaEB7JZFLcc05PPrxtNFV1DUz/zyreW5MhU97dlMWqOVRY6ZQGcY3i7SPoR0qkQG+to6XVvL3qMNOHxNM3NsToOCflNu/C1+c1UNdgZbpMrfUYSimmD4nn5wOF5MpUG4+3eHsutQ1Wpg+TJSZtoZQyK6U2K6W+sv+slFLPKKXSlVK7lVL3GZ1RCGe5MiWR6UPjeWFZOqsir4D44fDtI1BZZHQ0ITzWqG4RfHPfeEZ3i+APi3Zwz4ebKaupNzqWOMGRkmpqG6xO2QO9UedQP5SCbCnQW+2FpfvQGn57Xi+jo5yS2xToq3Ia6BoZyJDEMKOjiBaYPiwBreHzLTKK7ukWbs6ha2QggxNCjY7i6e4Hdjf5+UYgEeijte4LzDcilBCuoJTi6UsH0C0ykPs+2k7RpH9CTRksfszoaEJ4tIggX96+cQSPnN+bxTtyufillWzPlinv7mS/kzu4A3ibTcQE+8kIeivtzy/n441ZXDu6C4nhzmnk5whuUaBnH6ti7zHb6Lm7LdIXp9f4oYp0c/dsR0qqWXOoSH4H20gplQBcBLzR5OI7gT9pra0AWmvpmiXatUBfL/5zzXAqauu5b1kt1vEPwvaPIH2J0dGE8Ggmk+Ku1B7Mnz2augYrl726indWHZYp727iQL7zC3SwrUOXNeit8/clewnw8eKec3oYHeW03GJV/OdbjgDI9HYPNWNYPH/8fCe7jpTRL84913KI01u0JQet4dIh8jvYRi8AjwDBTS7rDsxUSk0HCoD7tNb7TjxRKTUbmA0QExNDWlpai++8oqKiVecZSTK7hhGZr+rtxdwdRTzOIP4Q2AWvT+9k/YiXsXg1b9RCnmfX8MTMHd2I5HC+vm88D328lSe+2ElKjJkx4yxO6xwumudAQSXhgT50CvRx6v3EhfmzLbvEqffRHm3KPMaSnXk8cF4vwp38d9RWblGgF1fW0Tfc5NZTDcSpTR0Ux5++3MWiLTlSoHsgrTULN+WQ0qUTSU7at7MjUEpNBfK11huVUqlNrvIFarTWKUqpGcBbwPgTz9dazwHmAKSkpOjU1NQTDzmjtLQ0WnOekSSzaxiReaLW5H+4mU925HLTZf+mz1czGF+zFKb+q1nny/PsGp6YWUB4oA9vXJ/Cf386yHPf7uHOeRt5/boUabRsoAMFFU5df94oPsyfJTtysVo1JpPMemwOrTV//XYPkUG+brfn+cm4xW/xH6b24+ERfkbHEK0UHuhDau9oPt+Sg8Uq06w8zc4jZezLr2D6MBk9b6OxwCVKqcPY1pmfo5SaB2QDn9mPWQgMMiaeEK6llOLZGQOJDfXj1u81tSm3w4a3IGOV0dGEaBdMJsXtE7tzQ38ffthbwL0fbqLeYjU6Vod1sKDC6dPbAeLD/KizWCmsqHX6fbUXaekFrD1UzH3n9iDQ1y3Gp0/LLQp0AJOse/VoM4bFk1dWy6oDhUZHES20aHMOPmYTFw2MNTqKR9NaP661TtBaJwOzgOVa62uBRcDZ9sMmAunGJBTC9UL8vHnxqqEcLa3hsWMXo0MT4OsHwSIdqIVwlNREb564uJ9t+u5HW2WwxAAlVXUUVtS5pECPs2+1Jp3cm2/e6gziQv2YNSLJ6CjNcsYCXSmVqJT6QSm1Sym1Uyl1vyuCCc9yTp9ogv28WCh7onuUBouVRVuOcHafKMIC3Hs9jgd7DrhMKbUdeBa41eA8QrjUsKROPDi5Fwt3lLCyx8OQvwvWvmZ0LCHalZvGduWxC/rw5dYjPPrpNqxSpLvUgcYO7tEumOLeSfZCb4maegs/Hyhkcv/OHrMEpDkpG4AHtdb9gNHA3Uqpfs6NJTyNn7eZiwbGsnhnLlV1DUbHEc20cn8hhRW1TB8qe587ktY6TWs91f59idb6Iq31QK31GK31VqPzCeFqd0zoztgeEdy2LprKLpPgh2ehVD7QFcKR7pjYnd9M6sknG7P56+I9RsfpUA7kVwLO7+AO/xtBl07uzbP6QBE19VbO6RNtdJRmO2OBrrU+qrXeZP++HNv+vrJYVfzK9KHxVNVZ+G5nntFRRDMt3JxDWIA3Z/eJMjqKEKIdM5kU/7pyCAE+3txzbBZaW2DJ40bHEqLduf/cnlw1Mok5Px1kS1aJ0XE6jAMFFfiYTSR0cn6z3RA/b4L9vGQEvZmW78knwMfMqG7hRkdpthatkldKJQNDgbUnua5NWwR56jYfkvt/rFoT4ad4Y9l2wkp/tYuUQ8jz7TjVDZpvt1UxLt6L1St/+tX17pi5OTw1txDtXXSIH3+9bBC3vbuBFT1uYOKu12Hf99BzktHRhGg3lFL87sI+/LAnn8c+3caX947D2+wZ03o92YGCCrpGBmJ2UVf1+DB/cqRAPyOtNcv35DO2RyS+Xp6zDWGzC3SlVBDwKfAbrXXZide3dYsgT93mQ3L/0lV1e/lP2n76DRtNdIjjO/PL8+04H2/Ios66jbunjmR4l06/ut4dMzeHp+YWoiM4r18M14xK4ra1Z7E16jv8v3kI7loD3rKTixCOEuznzZ+m9Wf2ext546dD3Jna3ehI7d6Bgkr6xga77P5sBXqNy+7PU+3LryCnpJp7zulhdJQWadZHakopb2zF+fta68/OdLzouKYPi8eq4YutR4yOIs5g4eYckiMCGJYUZnQUIUQH8n8X9SMhKoxHqq+HY4dgZfP2RRdCNN/k/p2Z0j+GF75PJ6Oo0ug47Vptg4XM4iqXrD9vFBfmT86xKpfdn6davicfgLN7e876c2heF3cFvAns1lo/7/xIwpN1jwpicEIon0k3d7d2pKSa1QeLmD40ASVbHAohXMjfx8yLs4ayuLoPG4LORq/8Fxw7bHQsIdqdpy4ZgLfZxO8X7kDr9tHVvd5idbtt5DKLqrBYtUsL9PhO/pTVNFBeI1tWns7y3fn0iw2hc6hnzdJqzgj6WOA64Byl1Bb714VOziU82KVD49l1tIy9ueVGRxGnsGhLDlrbGvsJIYSrDYgP5aHJvbmncAYWTLDk90ZHEqLd6Rzqx6Pn92bl/kIWbvb8gZOckmqmvLCCs/+Rxs/7C42Oc9zxLdZcPIIOcESmuZ9SaVU9GzOPeVT39kbN6eK+UmuttNaDtNZD7F/fuCKc8EwXD47DbFLt4j+D9khrzWebchiR3ImkCOd3GxVCiJO5bXw3unXvxUv102DPV7B/mdGRhGh3rhnVhWFJYfz5q10cq6wzOk6rHS6s5MrXVlNQXovZpLjmjbU89PFWt3hMBwpsSwi6RTl/D/RG8WGyF/qZ/LivAItVc3Z7LNCFaKnIIF8m9ori8y05WN1sGpKAHTll7M+vkL3PhRCGMpkU/7xyMPNMF3PEHIf+9lFoMP7NthDticmkeGb6QI5V1fPemgyj47TK3txyrnh9NdX1Fj68bTTf3j+eu8/uzqLNOUx6/kfD+x4dyK8gNtSPQN8WbY7VJo0FerYU6Kf0w558wgN9GJIYZnSUFpMCXTjF9KHxHC2tYc3BIqOjiBN8tjkbHy8TFw2MNTqKEKKDiw3154npw/h99TWoon2w7nWjIwnR7vSNDWFiryjeW5NBXYPV6Dgtsi27hJlzVmNS8NHtoxkQH4qft5mHp/Thy3vHkdDJn/s+3My3248alvFAQYVLp7cDRAf74m1WMoJ+CharJm1vPhN7Rbls6ztHkgJdOMV5/WII8vXiM5nm7lbqLVa+2HKESX2jCQ3wNjqOEEJwyeA4QgddxHLrUCw/PAfluUZHEk6glDpfKbVXKbVfKfXYSa6foJTapJRqUEpdfsJ1Nyil9tm/bnBd6vbjxrHJFJTX8o2BhWxL7c0t5+r/riXYz4uPbz+LHtG/3Masb2wIn901luSIAF5fcdCQjFprDhRU0t2F09vBNjOic6gfOcekQD+ZLVklHKuq98jp7SAFunASP28zFwzozOIduVTXWYyOI+x+2ldAUWWdTG8XQriVp6YN4FW/W7HU19Dw3R+NjiMcTCllBl4BLgD6AVcppfqdcFgmcCPwwQnnhgNPAKOAkcATSqlOzs7c3kzsGUW3yEDm/nzIYzq6v5q2HwV8fPtZp+yZYzYpbhrblS1ZJWzKPObagEBBeS0VtQ10c/EIOtimucsI+sn9sCcfs0kxsWeU0VFaRQp04TTTh8VTUdvA0t15RkcRdp9uyiE80IeJvTzzBUsI0T6F+nvzwMwL+G/DhXhtXwCZa42OJBxrJLBfa31Qa10HzAemNT1Aa31Ya70NOHEO9hRgqda6WGt9DFgKnO+K0O2JyaS4cWwyW7NL2ZRZYnScMyqsqOWb7blcNjzhjFtkXT48gWA/L95cechF6f7ncJFtL/LkSNeOoIOtk7sU6Ce3fE8+w7t08tjZoq7rZiA6nNFdI4gL9WPhpmwuGRxndJwOr6ymnqW78rhqRCI+XvLZnBDCvYzpHsHPo37L0Q0rCVz4Wxj0Z6MjCceJB7Ka/JyNbUS8teeedI9QpdRsYDZATEwMaWlpLQpZUVHR4nPcQXNzRzdo/L3gbwvXcucQY/eFPlPmLw/UUWex0suUR1pawRlvb2xnxbfbj/Lpt8uJ8HfOe5yTZf4p27YPee6+7aQdce17q4bSOo6W1vP98h/wOsU6a0/8N93WzMdqrOw6Ws2Vvbxd9tgd/TxLgS6cxmRSTBsaz5wVBykoryUq2NfoSB3at9uPUtdgZfowmd4uhHBP914wmOd338Ljx/5Op6ylwLlGRxIeRGs9B5gDkJKSolNTU1t0flpaGi09xx20JPeGml28veowfYaOPuPItDOdLnODxcrvVv/A2B4hXD11dLNur+eQapb+7Qf26lh+l9rXgUn/52SZNyzZi9l0gBnnp+Jtdm2BnhuQyRcHttNn6CgSOp18CYAn/ptua2Zbn4VNXHPeSAa7qIO7o59nGUYTTjVjaDwWq+ZLg7fAELbp7d2iAhmcEGp0FCGEOClfLzPTr7uXtda+dD00D11VbHQk4Rg5QGKTnxPslzn7XHGCG85Kxqo17605bHSUU1q2J58jpTVcNzq52efEh/lz/oDOfLguk8raBueFO0FGcRXxYf4uL84B4jvZtlqTRnG/tC27FG+zok9s8JkPdlNSoAun6hkTzID4EBZtkf9LjZRVXMW6Q8XMGBqPUp633YQQouPoExtK9pinCLBWcmDB40bHEY6xHuiplOqqlPIBZgFfNPPcJcBkpVQne3O4yfbLRCskhgcwqW8MH6zNpKbePZv4vrc6g9hQPyb1bVkH7pvHdqW8poFPNmY7KdmvZRRV0uUUDeycLc6+F/qRUinQm9qRU0qfziH4epmNjtJqUqALp7t0SDzbskvZn19hdJQOa5F9u7tpQ066bE84kFLKrJTarJT6yv7z20qpQ0qpLfavIQZHFMLtTZ8yma+8J9P18AKO7llndBzRRlrrBuAebIX1buAjrfVOpdSflFKXACilRiilsoErgNeVUjvt5xYDf8ZW5K8H/mS/TLTSjWOTOVZVz+duOHhyoKCClfsLuXpkEl4tHJUe3qUTQxLDmPvzIaxW13SqzyiqMqxAjw+TEfQTaa3Zll3CgHjPni0qBbpwukuGxGFSsHCz6z7RFP+jtWbh5hxGdQ0nMdyY/0Q6mPuxvQFt6mGt9RD71xYDMgnhUUwmhWnwtZSoYEo+vR+L5cTG3sLTaK2/0Vr30lp311o/Y7/sj1rrL+zfr9daJ2itA7XWEVrr/k3OfUtr3cP+Ndeox9BejOkWQZ/Owby7OsPoKL8yb00G3mbFrJFJrTr/lnFdOVxUxbI9+Q5O9mslVXWUVtfTJdz1HdzBtqVxRKAPOSU1hty/O8osrqKspoFBHr6cUwp04XTRwX6M7xnFos1HXPaJpvifrdmlHCysZMYwGT13NqVUAnAR8IbRWYTwdCHBwWQOeZi+9btY/vHLRscRot1QSnH58AR2Hikj075NmDuoqrNNT79gQGyrGwtfMKAzcaF+zP3Z+VuuZdifO6NG0MG2Dj1Htlo7blt2KQADPXwEXbq4C5eYMSye++dvYc2hIs7qHml0nA7ls03Z+HqZuGBgrNFROoIXgEeAEzuTPKOU+iOwDHhMa1174olt3R4IOuZ2KkaQzK5RUVGBDunPfnN3Bu/+J+9/1pX4cPdu+uOpz7OnZRZtN6V/Z57+ejdLduZy24RuRscBYNHmI5TXNHD9mC6tvg0vs4nLhifwyg/7Ka2uJ9TfeftgHy6qBKBLhDEj6ABxof7sL5AlpI125JTi42WiV4x7/19xJlKgC5eY0r8zwX5efLQ+Swp0F6prsPLl1iOc1y+GED/n/SclQCk1FcjXWm9USqU2uepxIBfwwbb9z6PAn048v63bA0HH3E7FCJLZNRozl3d5jcD3JuO3ez6jHn4Xfx/3bfzjyc+z6FgSwwPoHxfCYjcq0N9bk0Hf2BCGd+nUptsZ2yOSl5bvZ+3BIib37+ygdL/WOPsgycDlg/Gd/PkxvQCttTQBxjaC3rdzMD5enj1J3LPTC4/h523m0iHxfLsjl9LqeqPjdBhpe/M5VlUv09tdYyxwiVLqMDAfOEcpNU9rfVTb1AJzgZFGhhTC0wR3H0ler2u5tO5r5n7ymdFxhGg3zu/fmY0Zx8gvM34Nc1ZxFbuPlnH58IQ2F5pDk8Lw8zax6kCRg9Kd3OGiKmJCfA390DAuzJ/qegslVfLe2mrV7MgpZaCHrz8HKdCFC80ckUhtg5Uv3LBraHu1cHMOEYE+jO8ZZXSUdk9r/bi9wVEyti2Elmutr1VKxQIo2zuOS4EdxqUUwjPFTn+aap9OjN3zF5btPGJ0HCHahfMH2EaXv9uVZ3AS+DG9AICJvdr+fsXXy8yI5HBWHShs822dTmZxpaHT2wHiw/wAnLoOvbymnt1Hy1i6K4+5Px/i043ZaO1+PaUyiqsor21gUHyY0VHaTKa4C5cZEB9Kv9gQFmzI4roxyUbHafdKqupYtjufq0cl4d3CrUqEQ72vlIoCFLAFuMPYOEJ4IP8wfC/6K4MX3cZzn/yTQUl/aXUTKSGETY/oILpFBrJkZy7Xjm79um9HWJFeQHyYP92jHFPwntU9kr8u3kN+eQ3RwX4Ouc0THS6qItUBHyi0RXyYbXp9Tkm1w7cWK6+p54rXVrMnt/xX1x2rquPW8e6xNKLRtuwSABlBF6KlZo5IZEdOGTtySo2O0u59timHOouVK1MSjY7S4Wit07TWU+3fn6O1Hqi1HqC1vlZrLd1chGgF78FXUBk/jrut7/PMgjS3HMERwpMopZgyoDOrDxRRauAU6XqLlVUHipjQK9Jh66jH9ogAYLWTprlX1TVQUF5raAd3gLjGEXQn7IU+f10We3LLue+cHrx89VAW3T2W9b+fxJT+MTz77R7WHHTuEoKW2p5diq+XiZ7RQUZHaTMp0IVLXTokHh8vEx9tyDI6SrumtWb++kwGJ4TSLy7E6DhCCNF2ShE4/d8EmBo4O+MF5q1xvz2chfA05/fvTINVs2yPcdPct2SVUFHbwAQHLsfrHxdKiJ8Xq/Y7p4jMLG7cYs3YKe7hgT74epk4WurYAr3eYuWtnw8xuls4D0zuzdRBcQxJDCMq2Jd/XDGYLhEB3PPBJnJLje9f0GhbTin94kLwagezRj3/EQiPEhrgzQUDOrNocw419Raj47RbmzJLSM+rYNbIJKOjCCGE40T2wDT+t0wzr2LZNx+x9yRTL4UQzTcoIZTYUD8W78g1LMOK9ALMJsVZPRy3y4/ZpBjdLYKfnbQO/XCh8Xugg20WROdQP3LLfrV7a5t8ve0oR0trmH2SDv/Bft68fu1wquss3Pn+RmobjH8/b7VqduaUMsjD9z9vJAW6cLmZKYmU1TSwZKdx/xm0d/PXZRLgY+biwXFGRxFCCIdS4x+kIawrT5v/y8Mf/Ex1nfFvDoXwVEoppvTvzI/pBVTVNRiSYUV6AUMSwxy+Z/nYHpFkH6s+vh2aI2UW2/dADzd2BB0gJsSPPAeOZGutmbPiID2ig0jtFX3SY3rGBPP3KwazObOEP3+1y2H33VoHCyuprLMwMCHM6CgOIQW6cLnR3SJIDPdnwXqZ5u4M5TX1fLXtKJcMjiPIV/pACiHaGW8/vKb/h3gKmFH8Jk9/bfybQyE82eT+MdQ2WFlh76TuSsWVdWzLKXXo9PZGjevQndHN/XBRFWEB3oQGOPZDhdaICfEj14Fb5a06UMSuo2XcNr4rJtOpewJcODCW2yd2Y96aTBZtNnaHpu05JQAMlBF0IVrHZFJcOTyRVQeKnPKpZkf3+ZYjVNdbZHq7EKL96nIWauRsbvT6jv3rlrB4x1GjEwnhsUYmh9MpwNuQae4r9xeiNUzo5bjp7Y26RwURHezLz05oFJdZVGX4+vNGnUN8ySurcVjjzDkrDhIZ5Mu0IfFnPPbhyb0ZkhjG35fspd5idcj9t8a27FL8vc0O2wXAaFKgC0NcnpKAScHHG2UU3dHmr8+kT+dgBreDbSaEEOKUJj2BDkvmBf83+OMn6526D7AQ7ZmX2cR5/WJYtiefugbXFlkr0gsIC/BmkBOmJiulOKt7BKsPFDp814fDRZV0CTd2/XmjmBA/ahuslFa3vRP/3txyfkwv4MazuuDnbT7j8V5mE/ed24Ockmq+3HqkzfffWjtySunfThrEgRTowiCxof5M6BXFJxuzsVhlqxxH2ZFTyo6cMq4ameSwrUqEEMIt+QSipr1MrPUo9+gP+c38zTQYOIIjhCeb0r8z5TUNTpkOfipaa37aV8DYHpGYTzOVui3O6hFJYUUd6XmO2+G0rsHKkZJqkg1uENeoc6htqzVHTHP/708H8fc2c82oLs0+5+ze0fSOCea1Hw9gNeA9vcWq2ZFT5vB94I0kBbowzMyURI6W1rBin+vXPLVXH67LxNfLxKXNmJYkhBAer+t4GHEr16lv0RmreX5putGJhPBIY3tE4udtYkW66wr0vXnl5JXVMtEJ688bndXdtg795/2Oe1zZx6qwakhymynu9gK9jY3i8spq+HxLDlemJNAp0KfZ5ymluDO1O+l5FfywN79NGVrjQEEF1fUWBrWjmaNSoAvDnNs3hohAHz6SZnEOUVXXwOdbjnDRwFi3aFoihBAuMekpVGgirwW/xVtpu1hu4H7OQngqP28zw7t0YvVB5+wbfjKNTenGO2H9eaOETgF0iQhw6MyAjGL32GKtUYy9QM9r4wj6e6szsFg1N4/r2uJzpw6KJT7Mn1fTDrQpQ2tszy4FkAJdCEfw8TIxfWg83+/Oo7DCsfs3dkRfbTtKRW2DNIcTQnQsvkEw7WUi67L5V8h8frtgK1nF0oBUiJYa0y2C3UfLOFZZ55L7W5FeSK+YIGJD/Z16P2d1j2TtwWKHLYFpbHDsLgV6dIgvALmlbXsv/dP+QlKSw1vV/M7LbGL2hG5syDjG+sPFbcrRUttzSgn0MdM1Msil9+tMUqALQ80ckUi9RbNwk7HbM7QH89dl0j0qkBHJnYyOIoQQrtVtIoy9nwvqljBJr+LuDzZR2yD7owvREmPs08HXHnL+KHqtRbPucLFTtlc70VndIyivbWB7TqlDbu9wUSUBPmaignwdcntt5etlJjzQh7zy1o+g1zVY2X2kjCGJYa2+jStTEgkP9HH5KPr2nFL6x4U6rY+BEaRAF4bqGRPM0KQwFmzIcniHzY4kPa+cTZklzBohzeGEEB3UOX+A+OE85/0GxTn7efqr3UYnEsKjDEoIw9/bzGonbEt2or3FFuoarEzo5ZoCHWDNQceM7GYWVZEUHuBW77diQvzIa8Ma9D25ZdRZrAxuQzd9fx8zN52VzPI9+ew+Wtbq22kJrTV7c8vpGxvskvtzFSnQheFmjUhkf34FmzJLjI7isT5cl4m3WTFjmDSHE0J0UGZvuOxNvE2K+RFv8OGaA3y+RWZnCdFc3mYTKcmuWYe+q8iCj5eJkV3DnX5fEUG+JIb7s8OBI+juMr29UecQ3zZ1cd/qoHXc149JJtDHzOs/umYU/UhpDRW1DfTqLAW6EA510aA4AnzM0iyulWrqLSzcnMPk/p2JcJPpVkIIYYjwrjD1XyRUbOdvEd/w6KfbHPamXIiOYEz3CNLzKpzeG2h/iZXBCaHN2mvbEfrHhrLLAaO6Fqsmq7iaZDfp4N6oc6hfm5rEbc0qISLQh4RObesHEBrgzdWjkvhy21FySqrbdFvNkZ5bDkCvGCnQhXCoIF8vpg6K5attR6isbTA6jsdZsjOXkqp6rhohzeGEEIKBl8PQa5leuYDz/PYy+90NFJRLI1IhmmNMt8bp4M4bRa9tsHC41MqwJNf1zOkXF8Khwkoq2vg+M7eshjqLlSQ3G0GPDvajsKKOuobWNcLbll3CoIRQh0zbv35MMharZtFm589g2ptnL9CjpUAXwuFmjkikss7C19uOGh3F43y4LpPEcP/ja6yEEKLDu+BvqMie/MvrJXyrjnDHvI3SNE6IZhgYH0qQr5dT16HvPFJGg4ahSWFOu48T9Y8LAWjz2uiMokoAuoS73wg6QEErZj5U1DawL7+CwW1oENdUYngAI5PD+WxTttP7S6XnltM5xK/dbS8sBbpwC8OSOtE9KpAFG2Sae0scKqxkzcFiZo1IwtSOuld6MqWUWSm1WSn11QmXv6iUqjAqlxAdik8gzJyHl7WOReGvsDMjlz8u2inNSIU4Ay+ziRFOXoe+2d5zyJUj6P3jbGurd7ZxyUuGm22x1qizfS/03FY0ituRU4rWtKlB3IkuHRrPgYJKdh5xbrO4vXnl7W79OUiBLtyEUoqZIxLZmHGM/fnlRsfxGPPXZ2I2Ka4YnmB0FPE/9wO/aB+tlEoBZP87IVwpqjdc9iahpXtYFP8BCzZk8s6qw0anEsLtjekewcGCyjataT6dTZnHiPBTRNuLSleICfElItCnzQVjRlEV3mZFXJhz925vqRj7c9mav7Nt2SVA2xvENXXRwFh8zCY+c+I2yharZl9+Bb1j2s/+542kQBduY8awBLzNinlrMo2O4hHqGqx8ujGbc/pEu/Q/OXFqSqkE4CLgjSaXmYG/A48YlUuIDqvXZJj0JH2KlvKv2GX8+evdpO3NNzqVEG5tTLdIwHnr0DdnHKN7mGtLEKUU/eJC2lygZxZXktApwO323G6c4t6aEfStWaUkdPJ3aKPh0ABvzukTzRdbj9Bgad26+DPJKKqkrsHa7hrEAXgZHUCIRpFBvlw8KI6PN2Tx2/N6EerfvtaTONqy3XkUVtRx1chEo6OI/3kBWyHe9H+Le4AvtNZHT9d8RSk1G5gNEBMTQ1paWovvvKKiolXnGUkyu0aHzqwH0zd6ItPz32Ktfzi3v6t5fKQfyaGO7x7doZ9n0W70iwshxM+2Dn3aEMdu35pbWsOR0hpSY30cervN0S8uhLdWHqKuwYqPV+s+IMiw74HubjoFeONjNrVqBH1rdonD1p83denQeBbvzOXnA0VMdMJ+9+n2BnG92+EU9zMW6Eqpt4CpQL7WeoDzI4mO7JbxXflscw7z12Vy+8TuRsdxax+uzyI21I+JvaKNjiIApVTj6+RGpVSq/bI44Aog9Uzna63nAHMAUlJSdGrqGU/5lbS0NFpznpEks2t0+MzjRsPcC/hLwascCXyal7cn8umdo+ni4K2SOvzzLNoFs0kxsmuEU9ahb848BkAPF4+gg20der1Fsy+//Pia9JbQWpNZVMXwLu63Yk0pRXSIb4sL9KKKWrKPVXP9mC4Oz3R2nyhC/b1ZuCnbKQX63twKlIIe0R1zivvbwPlOziEEYHvxPKt7BG+vOky9k6bEtAdZxVX8tK+AK1IS3W6aVQc2FrhEKXUYmA+cA+wEegD77ZcHKKX2G5ZQiI7K2x9mfYDJL5S3vJ4jxpLLDW+tc/pez0J4qjHdI8goquKIg/ey3pR5DB8vE0khRhTotk7urZ3mXlkP5bUNbjmCDrZGcbktLNC3Zdua5jmyQVwjXy8zFw2KZcnOPKdso5yeV05SeAABPu1vQvgZfzu01iuAYhdkEQKA28Z342hpjWy5dhrz1mSggCtTpDmcu9BaP661TtBaJwOzgOVa605a685a62T75VVa6x6GBhWiowqJg+sW4qXr+DTo79SX5nLL2+upqnP8G0chPN3obuGA49ehb8osYWB8KF4GDC50jQgkwMfMrlYW6PnVtoEjdy3QY0L9yCtr2YeOW7JKMCkYEO+4BnFNTR8aT3W9he925Tr8tvfmlbfL9efgwDXobV0/6alroCS342mtiQ1U/OvbbYSWpNN03a475z4dR+aurNe883MVI2LM7N+6DmcNx8pzLYRod6L7wDWf4PfOJSyOfIFxOQ9y1/ubmHNdSqvXpArRHvXtHEJYgDerDxQxY5hjBgPqGqxszynlhjFdANc3azSZFH1jQ9h5pHVbrRVU2bZpTHKzLdYadQ7xY/nufLTWnK7nTVPbskvoGR1MoK9zRqGHJ3UioZM/CzcfYfpQxw0q1TZYOFRYyfn9OzvsNt2Jw/422rp+0lPXQElu57gvMJPHP9uOX9IgxnSPOH65u+c+FUfmfjXtADWWPfzhijFO+8QT5LluC611GpB2ksvb30IpITxNQgrMfI/gD2aytPOrTNh7L/d8YOKVa4bhbZYiXQiwFbOjuoY7dB36rqNl1DVYGZrUCYqM2U2hf1wIn27MxmrVmFo4ip9fZRtBT+zkvgV6db2FspqGZjVa1lqzNbuUc/s4r5eRyaSYPjSeV37YT35ZjcN2HTpYUInFqtvlHugg26wJNzV9aDwRgT68ufKg0VHcSk29hbd+PsT4npFOLc6FEKJd63EuzJhD9LHNfJ/wFj/uyuI387c4bTsgITzRqK4RZB+r5mipY9ahb8qwNYgblmRck7V+sSFU1lnIKK5q8bkF1ZrIIF+njTa3VXSIbZu05jaKyz5WTXFlnVM6uDc1bUg8Vg1fbD3isNs83sG9nU5xlwJduCU/bzPXju7C97vzOVBQYXQct7Focw4F5bXcIR3uhRCibQbMgItfIKHwJ5bFvcay7Yd54KOtWKza6GRCuIWhSWEAbMksccjtbco8Rlyo3/E9u43Q2L29NevQC6qsJIX7OzqSw3S2j043t0B3ZoO4pnpEBzEoIZQvHVig780tx8uk6Brp2J043MUZC3Sl1IfAaqC3UipbKXWL82MJAdeN6YKPl4k3Vx4yOopbsFg1c1YcZGC8rdO9EEKINhp+I0x7hYRj61ge8xLLth7g4Y+lSBcCbPuG+5hNbMkqccjtbc4ssU1vN1CvzkF4mVSr1qHnV2m3bRAHHP/gI7e0eQX61uwSfLxMLtlHfHK/GLZml1JQ7pidM9LzKugWFdhue4c0p4v7VVrrWK21t71D8ZuuCCZEZJAvM4bG8+nGbIor64yOY7ilu3I5WFjJ7RO7Nbv5hxBCiDMYei3M+C9xZVtZFvUvvt+8l4c+3ipbfTqYUup8pdRepdR+pdRjJ7neVym1wH79WqVUsv3yZKVUtVJqi/3rNZeH76B8vcz0iwthswMK9PyyGnJKqo+PyhvF18tMj+igFm+1VtdgpbhGkxThviO2MS0cQd+aVUK/2BCXFLmpvW3r3FekFzjk9tLbcQd3kCnuws3dMq4rtQ1W5q3JMDqKobTWvPrjQZLCA7hgQKzRcYQQon0ZeDnMfI/OVeksi/wnP27ezZ3zNlFTbzE6WbuglDIDrwAXAP2Aq5RS/U447BbgmH0ryn8Bf21y3QGt9RD71x0uCS0AGJIYxvbs0jb3Z9iUaV9/3sXYEXSwTXNvaYGeU1KNxn23WAPb8tCwAO9m7YVusWq255QyxMnrzxv1jwshOtiXH/a2vTlgVV0DmcVV7Xb9OUiBLtxcz5hgUntH8e7qwx36jdLaQ8VszSrhtgndMBuwd6gQQrR7fS6Cqz4kqiaDHzs9zcE9m7lx7jrKa+qNTtYejAT2a60Paq3rgPnAtBOOmQa8Y//+E+BcJdPFDDc0KYzqegt77U25WmtzZgk+ZhP940IclKz1+sWFUFhRS34zR5oBMooqAfcu0AFigv3ILT3zNPIDBRVU1VkYlOCahsNKKVJ7R7EivaDNH/bsy7P1pmqvHdzBgdusCeEst43vxjVvrOWLLUdw3kYQ7u21Hw8QGeTDFcMdt4ekEEKIE/SYBDd8RfCHs1gc9CduyriPa96w8PZNIwkP9DE6nSeLB7Ka/JwNjDrVMVrrBqVUKdDYcKWrUmozUAb8n9b6p5PdiVJqNjAbICYmhrS0tBaFrKioaPE57sCZuWvtW4t99P06zk4689Zdp/LD9moSg2D1SttfnZHPdX2xbcDnwyUrGRzVvFJoWabtg7qcvVtIy3Df8U1vSw0HciqPP7enep7X5zYAUJ69l7Sy/S7JFtXQQFlNA2998QO9OplPedyZ/m38lG37uyg5vIu0gj2Ojtkqjv73LAW6cHtndY+gT+dg3lh5kMeHdLzGPbuPlpG2t4CHJvfCz/vUL2hCCCEcIHEE3LYMn/ev5L2G5/h93q1c8VoDb980kkQ3Hz1rp44CSVrrIqXUcGCRUqq/1vpXc5S11nOAOQApKSk6NTW1RXeUlpZGS89xB87MrbXmuY3fU+kfTWrq4FbdRl2DlYzvl3Dt6C6kptpWNhj5XA+rqee5dd/hFZlMamqPZp3z89e78DYdYtrks1u8f7orfVO4lbS9Bcef21M9z3t+PABb9jBj8gSC/Vr/wUtLDKup5/VtSynxjyc1tc8pjzvTv42VX+3C1yuDyy84221mlTr637P7fgQkhJ1SitvGdyM9r4IdhR1vmvucFQcJ8LFtOyeEEMIFOiXDLd9h6jqOZ82vMat8LjNeWclWB3Wz7oBygMQmPyfYLzvpMUopLyAUKNJa12qtiwC01huBA0AvpycWgO092JDEsDZ1ck/PK6e2weqy9c5nEuLnTVJ4QIs6uWcUVREVoNy6OAfbVmuFFbVnnEaeUVRFeKCPy4pzsD3vw7t04oe9bWsUtzevnJ4xQW5TnDuDFOjCI1w8OI7oYF8WH+5YawGzj1XxxdYjXDUyibAAmV4phBAu4x8G13wCw2/kNhbxsv4Lt89ZwpKduUYn80TrgZ5Kqa5KKR9gFvDFCcd8Adxg//5yYLnWWiulouxN5lBKdQN6AgddlFsAQxPDOFBQQVkr+zHsyLEVwgPjXbPeuTn6x4W0qFFcZnEVUf7uXzbFhPph1VBQcfp16JnFlYaspz+7TzS7j5Y1eyu4k2nvHdxBCnThIXy8TNxwVjI7i6zsPtqyzpue7M2Vh1DYutkLIYRwMbM3TH0Bpr7ASLWTr7x/x2vvz+fNlYfQuuMtuWotrXUDcA+wBNgNfKS13qmU+pNS6hL7YW8CEUqp/cADQONWbBOAbUqpLdiax92htS526QPo4IYkhaE1bMtq+d7hANtzSgn286JLhPssEekfF0JGUVWzmkBqrcksriI6wP1HbDuHNG8v9IyiKkP+Ps62b7f2Y3rrurmXVNWRV1bbrju4gxTowoNcMyoJH7OtaO0IjlXWMX9dFpcMiSMuzN/oOEII0TEpBSk3oW75jvCQQD72+TNZ3z7PHxZtl73SW0Br/Y3WupfWurvW+hn7ZX/UWn9h/75Ga32F1rqH1nqk1vqg/fJPtdb97VusDdNaf2nk4+iIBiWEAbDZvlVaS+04Ukb/uBDcqSl/j2hbgXewoPKMxxZV1lFVZyHaE0bQm7EXer3FypGSaroYMILeKyaIuFA/ftjTumnu6R2ggztIgS48SFiAD+Pjvfh8S06LtsbwVO+tyaC63sIdE7sbHUUIIUTcUEy3/4i51ySe9H6XsZse4K4531FcWWd0MiGcKtTfm+5Rga1ah15vsc18dKfp7QA9ooMA23ZjZ5JZXAVAlAeMoP+vQD/1FPecY9VYNYY0vVRKkdonmpX7C6lraPkHnI3b/ckUdyHcyOQu3jRYNe+sPmx0FKeqrrPw9qrDnNsnut2/CAkhhMfw74Sa9SGc92emeG3mmdzb+cu//92hll6JjmloUie2ZJW0eGnH/vwK6hqsDHCzAr1LRABeJtW8Ar2osUB3/7IpItAHb7Mi9zQDWRn2Dxy6RAS6KtYvnN07moraBjZktHylSnpuOcG+XsSF+jkhmftw/39pQjQRE2hiSr/OvLMqg4Ly0zfA8GQfb8yiuLKO22X0XAgh3IvJBGPvw3R7GsHhMfyj7mm2vnYzS7ccMDqZEE4zJDGMoso6so9Vt+i87fYGce5WoHubTSRFBHAg/8xT3I+PoPu7/wi6yaSIDvYj7zRr0DOLbI/ZqJ4AZ3WPwMdsIq0V3dz35pXTq3OwWy2XcAYp0IXHeeT83tQ2WPjHkr1GR3GKBouV//50kGFJYYxI7mR0HNFCSimzUmqzUuor+89vKqW2KqW2KaU+UUoFGZ1RCOEAnQfif9cKKoffxZXqe3p8dgFbtm/BYpXmcaL9adwibVML16HvzCkl0MdMV4NGa0+ne1QQ+5s5xT0mxBcfs2cUhTEhvqcfQS+qws/bRHSwrwtT/U+grxejuoXzw56WNYrTWts7uLf/t1FSoAuP0y0qiBvPSuajjVlsz25dR1F39s2OXLKKq7ljYvd2/wlhO3U/ti7FjX6rtR6stR4EZGLrZCyEaA+8/Qi8+Fnqr/2CUF8Tvyl6ghX/vIpjRa3rUCyEu+rTORg/b1OL16Fvzymlf1yoW+4f3j0qiIyiyjM2e8wsqjJkS7LWignxO+MU96TwAEPfY07sFcW+/Aqyj1U1+5yCilpKquo7xNJPKdCFR7r33J6EB/jw1Jc729VWN7UNFl74Pp3uUYFM6htjdBzRQkqpBOAi4I3Gy7TWZfbrFOAPtJ9/sEIIAHx7TCD84Y2sCr2YCRWLsb40gowV70M7+v9JdGxeZhOD4sNaVKBbrJpdR8voHx/ivGBt0CM6iHqLJqv49EViZnEVSeHuNwPgVGJC/Mg/TZM42wcOxj6eVPt2az/tK2z2Oem5ttkO7X2LNQAvowMI0Rohft48PKU3j322nS+3HeWSwXFGR3KIN346xMGCSt6+aYRbftoszugF4BHgF/97KKXmAhcCu4AHT3aiUmo2MBsgJiaGtLS0Ft95RUVFq84zkmR2DcnsGhU9Z/F1+QR67v0PfZffRfqaNygecBs1Ae77f5QnPs/CGEOSwnh71WFqGyz4epnPePyBggpq6q1u18G9UfcoW5F6oKCSblEnnzZdU28ht6zGPoLeum3mXK1zqB8VtQ0n3eO9cU/3cT0jDUj2P92jAokM8mH94WKuGpnUrHOOd3Bv51usgRTowoNdkZLIu6szeO6b3ZzXNwZ/nzP/Z+HOsoqreHHZPi4c2Pn4J4vCcyilpgL5WuuNSqnUptdprW9SSpmBl4CZwNwTz9dazwHmAKSkpOjU1NQTDzmjtLQ0WnOekSSza0hm10hLSyN16myKy6/l/TefYNqxd+m2/j6so+/GJ/Vh8HW/tZOe+DwLYwxJDKOuwcruo+XH16Sfzg43bRDXqLEoP1BQwXmcfNZi4xTsLhEB4CGrKrvbH9ee3PJfXVdQXkt1vcXwKftKKYZ36cTGjOZ/6JGeW054oA+RQcasnXclmeIuPJbZpHji4n4cKa3h9RWe3T1Xa80TX+zEy6T4w9R+RscRrTMWuEQpdRiYD5yjlJrXeKXW2mK//DJj4gkhXCU8OIBZ9/2N+aMX8UXDKHxWv0D9i8Nh+ycy7V14rKFJYQBsaWajuO05pfh5m44XjO4m1N+bqGBfDuSfulFcYwd3I/YMb63Gv6dNJyl+Gx9PkkEd3JtK6RJORlEV+eWnXi/fVHp+x2gQB1KgCw83qlsEFw2K5bUfD5BT0rKtP9zJd7vyWL4nn9+e14vYUH+j44hW0Fo/rrVO0FonA7OA5cB1SqkecHwN+iXAHuNSCiFcxWxS3HrBGDrf+A43m58hvcIfPr0F/eZkyFxrdDwhWiw21J+YEF+2NrNB786cMvrFhmB24yV73aMCT7sXeoZ9D3SjR5xbIjLIl6TwgJN23G98PF3c4PEMt+9UtPHwmT/w0VqTnlveIdafgxTooh14/II+aA3PfeuZdU9lbQNPfbGTPp2DufGsZKPjCMdSwDtKqe3AdiAW+JOxkYQQrnRW90ie+82tPJvwCo/U30bZ0QPw1mRYcC0U7jc6nhAtMjA+9PjU9dOxWjU7j5S67frzRt2jgtifX3HKhsOZxVUE+JiJDPJxcbK2Gd6lE5syS371uDKKqzApSOhkfIE+IC4UXy8TG5oxzT2npJrKOkuHWH8OUqCLdiChUwC3T+zOl1uPsP5wsdFxWuzFZfs4UlrD05cOwMssv5LtgdY6TWs9VWtt1VqP1VoP1FoP0Fpf09jVXQjRcUQH+/HOLWeReM7tjK3+B//1ugrLvuXwykj4+kEozzU6ohDN0j8ulAMFFVTVNZz2uENFlVTWWejv5gV6j+ggymoaKKyoO+n1WW6wJVlrDEsKo6C8lsLqXxbomUWVxIb64+Nl/PtNHy8TgxPDmlWgp9sbxMkIuhAe5I6J3egc4sdTX+7EavWc9X17c8t5c+UhZqYkkpIcbnQcIYQQTmI2Ke49tyfv3nE27/nMZEzlP9gSfSl649vw7yHw3R+gssjomEKc1oD4UKwadh89/WfNjaPsnjCCDpxymntGUZVHrT9vNDTJNn38QMkv93jPKK6yNbxzEyldOrEzp5TqOstpj0vPs/399JQCXfx/e3ceXVV9rnH8+2YmZGRICASIhEEgBAmDoiKotaJVaau2qLVatdShg3pbq12trk7XotVq1VZtdVWtdaJWEbUKF6i2IggUmcEAhnkmEGZCfvePc4IhJORIkj0kz2ct1jrJ2QnP2cl+V96zf4OER2pSAnddeDIL1+1iwpy1fseJiXOOn722kPSUBO684GS/44iIiAdKumXz5vfPZMSg/ny57FJuynqCXT0uhA8egYcHwrT/hf0hWS5aWp3qhnvhuoYb9KSEOHrmBHtRr8Kc+hv06i3JgjBf+/M6uVM6qUnxlJYf3fiu3hawBr0gm8oqx8dry4973PKNFXTKSCGzTaI3wXymBl1ajEsGdmZw92zue2dpnXs/Bs2EOWuZ9el27rzgZLLbhmtuk4iInLj0lEQe+NpAHrliEDN2ZDBk8eW8OPQVqgrPgX+Nh98NgGn3wr5w7LssrUduRjId0pIanIe+YN1O+uZlkBjwqXt5GSm0SYxnxeY9xzy3peIAByqrArHi+eeVEB9HcX7mUXfQdx+oZNueg3Rr19bHZEcrid7pn93AFNVlmypazfxzUIMuLYhZZNu1rbsP8ui0YC+8U773IPe+vZTB3bO5fHBXv+OIiIgPLh7Ymcm3n8U5fXK48/2DjNk8jlWXvQ0njYB//QYeKoapv4K94VtfRVomM6N/50wWHKdBr6pyLFq3i6LOGR4mOzFxcUaPelZyX7El0rSHcYg7RJrf1RVV7D8UuYteti3yeoK0In1WahK9c9OOOw/9cJWjdPNu+rSSLdZADbq0MMX5WVw2OJ+n/72KVVuPfTc0KMb/cxk79x3iV18uIi7A24+IiEjzyklP4fGrB/OHq0pYX76PL75Qzm+z72b/9e9B4dnw3v3w0AB496daTE4CoahLBp9s3n2k8att9fa9VByoDPz882o9cyIrudf25oL1JCfEHbnLGzYl3bI57GB+dFu81dVbrAVsRMDg7u2YW7aj3jWkVm/fy4HKqlYz/xzUoEsLdMf5fUiKj+PXby7xO0qd5q7ewQuzVvOt0wvomxf8d5dFRKT5XTggj8m3j+Si4s48Oq2Uc/66lTdPHo+76QPoPRpmPBZp1N+4Fbav8juutGJFnTM5XOVYtrGizucXro80hEUhadALO6axrnzfUQuV7T90mInz1jO6qFNo5z0P6pYFcGQ/9NXbo3u6B6xBH9I9m137K/mkjjdJgCO/Z61lBXdQgy4tUE5GCt89pxdTlmzi2Rmf+h3nKJWHq/jpPxbSKSOFW8/r7XccEREJkHZtk/jd10/hlRuHk5WaxC1/m8uVr1ew7MyH4Htz4JSrYN7z8EgJTLgO1s/zO7K0QtWNd3UjXtuCdTtJio+jd0gaquqV3Fdu/axBfHfxJnbtrwz1NMT2acnkphpzo8PHy7bvJTs1kYyUYL3hMKQgMkKhvq2Sq7dY66Uh7iLh9u0RJ/GFvjncM3ERby3Y4HecI56dUcbiDbu45+J+pCUn+B1HREQCaGhBO9743pn88stFLNm4iwt//z4/nrqb9SPuhR/Mh+G3wPJ34cmR8MwlUDoFXHi2GJVwy89uQ2abxHoXipv96Q5OzksPxF7bsSjMiSyaVj3nHOCV2WvoktWG0wvb+xWrSRRmxTN3dXlkRfpte+nWPjgLxFXr1i6VDmnJzKlnHvryTRV0a5dKalLr+bs5HFeOyOeUEB/HI1eUMKhrFre+NI+ZK/3fW3bemnIeeHcZI3t3ZHRRJ7/jiIhIgMXHGVef1p1p/zOKa4YX8I//rmPU/dP5xb92sO30n8Hti+ALP4ety+Gvl8LjZ8K8F6DyoN/RpYUzM4q6ZNS51dr68n3MKdvBF/vl+pDsxBS0b4sZrIgOsV5Xvo9/l27l0sH5oV8nqGdWHFt3H2Dtjn2Ubd8TyC3jzIyhBdnMLqv/DnrvVnT3HNSgSwvWJimep64ZSn52G254dna9c6W8sLL8MFc/NZP2acmMv7QYs3AXfBER8UZ22yTuvrgf0340iq8M6sJfPljFWfdN44H3NlJecnPkjvqYP0DVYXjtxsg89fd+q5XfpVkVdc5k2cYKDlZWHfX5N+dHRi1eVNzZj1gnJCUxnq7ZqUdWcn91zlqcg8sH5/ucrPEKsyKt3sxV21lfvj9wC8RVG9w9mzXb97F51/6jPn+wsoqVW/aEZrpEU1GDLi1adtsknr1uGG0S47nm6VmsL9/neYZ5a8q5f/Z+slOTeHHcaXTKTPE8g4iIhFuXrDaMv6yYybePZFSfHB6ZWsoZv5nKfVNWsr335XDzDPjGq5DbH6b+Eh7sB5Nugy3L/I4uLVBRl0wOHq7ik81H3/x4Y/56ivMzKegQvKHUx9MzJ40VW/bgnGPC3LWc1qNdaLdXqyk/LY7UpHgmzV/P4SoX2Nc0pKAdwDHbra3auofKKkefVrQHOqhBl1YgPzuVZ64bxp4DlVzz9CzK93o3/G/emnKufmomaYnGi+NOo3NWG8/+bxERaXkKO6bx2FUlvHPrWZx9cg5//NcKzhw/lXv/uZRtnc6Eq1+Fm2bAgMvgv8/DY8MiQ+A/mQJVVQ3/ByIxOLJQXI156J9u3cP8tTu5OER3z6sVdmzLyi27+XDldsq27eVrQ8K7OFxN8XHGwPws3v9kK0Agh7gD9O+cQUpi3DELxVUvEKc76CItUN+8DJ745mDKtu3l28/OrnfvzqZU3ZxnpyZx57AUNeciItJk+nRK59ErS5h821mc1y+XP723khH3TeO37yxjZ3ovGPMo3L4Yzv4pbFwIz18KfzgVZv0JDtS9nZFIrLq3SyUtOeGoeeiT5q8H4EvFeX7FOmGFHdM4UFnFQ1OWk5acwAVF4XsN9RncPZvD0T3GuwdwkTiAxPg4TumaxYwV2zhQ+dmCl8s3VRAfZ/ToGMzczUUNurQapxd24MGvD2R22Q6+/8J/jxSr5lCzOX9x3Gm0b6NLTUREml7PnHQeHjuId28byTkn5/DotFLOvG8qv/+/T6iIz4SRP4JbF8BX/wRJbeGtH0aGv//zJ7B9pd/xJaTi4ox+nTOO2mrtjY83MLQgO5Q3JApzIouQzVy1nYuK82iTFO9zoqZT0j0LgOSEOHLSk/0Ncxzn9+/E0o0V3Dp9Lz97bSFLNuxi2cYKCtqnkpzQcn4esVDXIK3KRcWdufuifry7eBN3v74Q1wzb0tRszl/QsHYREfFAz5w0Hr2yhLd/MILhPdrz4OTljLx/Oi9/tIaquEQo/hp8expcPwV6nQeznoDfl1C04Fewo8zv+BJCRZ0zWbJhF5WHq1i2sYJlmyq4eGD4hrfDZ3uhA1w+JPyLw9U0qGtkn/Fu7VIDvSr9tacXMOHG4QzKSeCl2Wu44OH3mbJkU6ubfw5q0KUV+tYZJ3HjyEKen7maR6eWNun3rt2cd1FzLiIiHuqbl8GT3xzCxO+eQY8Obbnj7/P56h8/YMHanWAGXYfCZU/BrQth5B203bMG2mT5HVtCaEB+BvsPVbFiyx4mzV9PnBHaoeHt2iaRnZpIj45tKemW7XecJpXdNok+uemBn8dtZgwpaMe44mRm3nUuP/1SX4q6ZDI6pL9TjdF6dnwXqeHHo/uwuWI/D0xeztod+7j2jAL65mU06nuqORcAM4sHZgPrnHMXmdnzwBDgEDAL+I5z7pCfGUWk5SvOz+KVG4fz6tx13Pv2Ui557N9cMawbd5zfh6zUJMjIg7N/wkyGMyol0++4EkJFnSO/NwvW7WTS/A2cXtiBjgEeQt2Quy/uR256SovcCvcv1w0N1TDx7LZJ3DCiBzeM6OF3FF+oQZdWycwYf2kx6cmRYTQvzV7DsJPacc3wAr7YP5fE+NgGlzjnWLxhF1OXbObJ91eqOReAHwBLgOp3fJ4HvhF9/DfgBuCPPuQSkVbGzLh0cD7n9c/ld5OX8+yMMqYv3czDVwxiaHRbI1pgMyLe6NExjZTEOF76aDWrtu7hxpHhbqa+MqhlDW2vKS9Tf5eGSUwNupmNBh4G4oE/O+d+06ypRDyQGB/Hz8cUcdt5vXl59hqe+7CMW/42l9yMZK46tTtjh3UlJ/3YPcv3HzrMjBXbmLJkE1OXbmbDzv2YwdDu7fjd2FPUnLdiZpYPfAn4NXA7gHPurRrPzwJa7l8AIhJIGSmJ3HNxf74yqAvfe+G/fP2JGdz2hd7cfHZPv6NJiMXHGf3yMvjo0x0kxhvn9+/kdySRFqHBBj06XPMx4DxgLfCRmU10zi1u7nAiXshKTWLcWYVcf2YPpi/bzDMzynhw8nIemfoJFw7I45vDC+ia3YapSzczZclm/lO6lX2HDpOaFM+IXh247bzenN0nJ9TDuqTJPATcARwz0cvMEoGridxhP4aZjQPGAeTm5jJ9+vTP/Z/v3r37hL7OT8rsDWX2Rhgy3zkInlkUzwOTl/PWnFKuKjwc+MwSXEVdMpm7upyzenWMTJ0QkUaL5Q76MKDUObcSwMxeBMYAatClRYmPM87tm8u5fXNZuWU3z31YxoTZa3l93vojx3TJasPlQ/I5t28up57UjpTE8MznkeZlZhcBm51zc8xsVB2H/AF4zzn3fl1f75x7EngSYMiQIW7UqLq+xfFNnz6dE/k6PymzN5TZG2HJPPpcxytz1nLP64sY/7Hx91sGB34BKQmmoi6ReehhXb1dJIhiadC7AGtqfLwWOLX2QY29+xOGd53rotze8jL3yHQ4dUQSH26IY88hR3HHBPLTDLOtuPVb+XB9w9+jWhjPdxgzg6+5zwAuMbMLgRQgw8z+6pz7hpndA3QEvuNHMBGRmsyMrw3pSkm3LO558QMK2rf1O5KE1IUD8ti2+yAXDNDwdpGm0mSLxDX27k9Y3nWuTbm95Ufu0U3wPcJ4vsOYGfzL7Zy7C7gLIHoH/YfR5vwG4HzgXOdclefBRETq0TMnnW8XJ5OUoF135cSkJSdw06hCv2OItCixVOR1QNcaH+dHPyciIg17HMgFZpjZPDO72+9AIiJ+MLPRZrbMzErN7M46nk82s5eiz880s4Iaz90V/fwyMzvf0+AiIh6K5Q76R0AvMzuJSGM+FriyWVOJiISYc246MD36WNtZikirF+Oiw9cDO5xzPc1sLDAe+LqZ9SPy92d/oDMwxcx6O+cOe/sqRESaX4N30J1zlcB3gXeI7O37snNuUXMHExEREZEW48iiw865g0D1osM1jQGeiT6eAJxrZhb9/IvOuQPOuVVAafT7iYi0ODHd2Ynu4/tWgweKiIiIiBwrlkWHjxzjnKs0s51A++jnP6z1tV1q/wdasDg8lNkbyuyNps6soZciIiIiEnpasDg8lNkbyuyNps6sZTtFREREpLnFsujwkWPMLAHIBLbF+LUiIi2CGnQRERERaW5HFh02syQii75NrHXMROCa6OPLgKnOORf9/NjoKu8nAb2AWR7lFhHxlIa4i4iIiEizis4pr150OB542jm3yMx+Acx2zk0EngKeM7NSYDuRJp7ocS8Di4FK4Bat4C4iLZVF3phs4m9qtgUo+5xf1gHY2uRhmp9ye0u5vRPGzBBb7u7OuY5ehDkRJ1hDIZw/M2X2hjJ7ozVlbol1NIw/PwhnbmX2hjJ7o0nraLM06CfCzGY754b4nePzUm5vKbd3wpgZwpu7KYTxtSuzN5TZG8ocbmE9F2HMrczeUGZvNHVmzUEXERERERERCQA16CIiIiIiIiIBEKQG/Um/A5wg5faWcnsnjJkhvLmbQhhfuzJ7Q5m9oczhFtZzEcbcyuwNZfZGk2YOzBx0ERERERERkdYsSHfQRURERERERFotNegiIiIiIiIiAeB5g25mo81smZmVmtmddTyfbGYvRZ+faWYFXmesSwy5rzWzLWY2L/rvBj9y1sr0tJltNrOF9TxvZvb76Guab2YlXmesSwy5R5nZzhrn+m6vM9aRqauZTTOzxWa2yMx+UMcxgTvfMeYO4vlOMbNZZvZxNPfP6zgmkLWkKYSxjoathoaxfqp2eiOMdbO118zaVEO9oTrqDdVRb3haR51znv0D4oEVQA8gCfgY6FfrmJuBx6OPxwIveZmxEbmvBR71O2utTGcBJcDCep6/EHgbMOA0YKbfmWPMPQqY5HfOWpnygJLo43RgeR2/I4E73zHmDuL5NiAt+jgRmAmcVuuYwNWSJnrtoaujYayhYayfqp2Byhyoc92aa2Yd50I11LvcqqPeZFYd9SazZ3XU6zvow4BS59xK59xB4EVgTK1jxgDPRB9PAM41M/MwY11iyR04zrn3gO3HOWQM8KyL+BDIMrM8b9LVL4bcgeOc2+Ccmxt9XAEsAbrUOixw5zvG3IETPYe7ox8mRv/VXvEyiLWkKYSxjoauhoaxfqp2eiOMdbOV18zaVEM9ojrqDdVRb3hZR71u0LsAa2p8vJZjfxhHjnHOVQI7gfaepKtfLLkBLo0OG5lgZl29idYosb6uIBoeHWLytpn19ztMTdHhLIOIvLNWU6DP93FyQwDPt5nFm9k8YDMw2TlX7/kOUC1pCmGsoy2xhgb6ej6OwF3L1cJYO8NUN1txzaxNNTQ4AnttNyBQ13ZNqqPNy6s6qkXims4bQIFzrhiYzGfvnkjTmwt0d84NBB4BXvM3zmfMLA34O3Crc26X33li1UDuQJ5v59xh59wpQD4wzMyKfI4kjaMa2vwCeS1DOGtn2OqmamaLpxrqjcBd29VUR5ufV3XU6wZ9HVDzHb386OfqPMbMEoBMYJsn6erXYG7n3Dbn3IHoh38GBnuUrTFi+XkEjnNuV/UQE+fcW0CimXXwORZmlkikyDzvnHu1jkMCeb4byh3U813NOVcOTANG13oqiLWkKYSxjrbEGhrI6/l4gnoth7F2hrlutsKaWZtqaHAE7tpuSFCvbdVRbzV3HfW6Qf8I6GVmJ5lZEpHJ8xNrHTMRuCb6+DJgqnOu9vh+rzWYu9Y8jkuIzKUIuonAN6MrO54G7HTObfA7VEPMrFP1fA4zG0bk99jXPyKieZ4CljjnHqznsMCd71hyB/R8dzSzrOjjNsB5wNJahwWxljSFMNbRllhDA3c9NySg13LoamcY62Yrr5m1qYYGR6Cu7VgE7dqO5lAd9YCXdTShETk/N+dcpZl9F3iHyIqUTzvnFpnZL4DZzrmJRH5Yz5lZKZFFGsZ6mbEuMeb+vpldAlQSyX2tb4GjzOwFIisgdjCztcA9RBY0wDn3OPAWkVUdS4G9wLf8SXq0GHJfBtxkZpXAPmBsAP6IOAO4GlhgkbkpAD8BukGgz3csuYN4vvOAZ8wsnkjBftk5NynotaQphLGOhrGGhrF+qnZ6Jox1s9XWzNpUQ72jOuoZ1VFveFZHzf/fKRERERERERHRInEiIiIiIiIiAaAGXURERERERCQA1KCLiIiIiIiIBIAadBEREREREZEAUIMuIiIiIiIiEgBq0CXQzCzLzG72O4eISBiphoqINI7qqHhNDboEXRagoigicmKyUA0VEWmMLFRHxUNq0CXofgMUmtk8M7vf7zAiIiGjGioi0jiqo+Ipc875nUGkXmZWAExyzhX5nUVEJGxUQ0VEGkd1VLymO+giIiIiIiIiAaAGXURERERERCQA1KBL0FUA6X6HEBEJKdVQEZHGUR0VT6lBl0Bzzm0D/mNmC7Uwh4jI56MaKiLSOKqj4jUtEiciIiIiIiISALqDLiIiIiIiIhIAatBFREREREREAkANuoiIiIiIiEgAqEEXERERERERCQA16CIiIiIiIiIBoAZdREREREREJADUoIuIiIiIiIgEwP8DowR6LKUYJT4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Plot a solution from the test set:\n", + "plot_idx = 321 # <- can you change!\n", + "\n", + "u_model = deepOnet(tp.spaces.Points(t_tensor, T), D_tensor_test[plot_idx]).as_tensor[0]\n", + "ref_solution = u_tensor_test[plot_idx]\n", + "\n", + "plt.figure(0, figsize=(14, 4))\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(t_tensor[::2], D_tensor_test[plot_idx])\n", + "plt.title(\"D(t)\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(t_tensor, u_model.detach())\n", + "plt.plot(t_tensor, ref_solution)\n", + "plt.title(\"Solution\")\n", + "plt.legend([\"DeepONet\", \"Real Solution\"])\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(t_tensor, torch.abs(ref_solution - u_model.detach()))\n", + "plt.title(\"Absolute Difference\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Now a test for constant values of D:\n", + "test_D = 0.05\n", + "\n", + "def analytic_solution(t, D):\n", + " return 1/D * (-torch.log((1+torch.exp(-2*torch.sqrt(D*g)*t))/2) - torch.sqrt(D*g)*t) + H\n", + "\n", + "# Evaluate model:\n", + "u_model = deepOnet(tp.spaces.Points(t_tensor, T), lambda t: test_D*torch.ones_like(t)).as_tensor[0]\n", + "ref_solution = analytic_solution(t_tensor, torch.tensor(test_D))\n", + " \n", + "# Plot\n", + "plt.figure(0, figsize=(14, 4))\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(t_tensor, u_model.detach())\n", + "plt.title(\"Neural Network\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(t_tensor, ref_solution)\n", + "plt.title(\"Reference Solution\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(t_tensor, torch.abs(ref_solution - u_model.detach()))\n", + "plt.title(\"Absolute Difference\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Lastly, we can also evaluate the network with a custom non discrete function:\n", + "def test_fn(t):\n", + " return 1.1 + torch.sin(3.5*t)\n", + "\n", + "u_model = deepOnet(tp.spaces.Points(t_tensor, T), test_fn).as_tensor[0]\n", + "plt.plot(t_tensor, u_model.detach())\n", + "plt.title(\"Neural Network\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instead of using the DeepONet architecture, we could also try to learn the solution operator with a simple \n", + "fully connected neural network. E.g have network with input $(t, D(t_1), \\dots, D(t_N))$ and output $u(t; D)$.\n", + "\n", + "This is implemented in the following cell and a comparision is shown in the last cell." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 5.0 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "5.0 K Trainable params\n", + "0 Non-trainable params\n", + "5.0 K Total params\n", + "0.020 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f3abce76c8ae4450b360e831edf1f934", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n", + "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " warnings.warn(*args, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d29536bbb08d4559a53c5fe7e7b5ecd4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4bf657d088a44fb696e06f50b56ef1f5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### Compare with simple FCN:\n", + "D_vec = tp.spaces.Rn('D', 30)\n", + "\n", + "fcn_model = tp.models.FCN(T*D_vec, U, hidden=(42, 42, 42))\n", + "\n", + "# permute data and create condition:\n", + "complete_data = torch.zeros((len(D_tensor_train), 60, 31))\n", + "complete_data[:, :, :1] = t_tensor\n", + "complete_data[:, :, 1:] = D_tensor_train.squeeze(-1).unsqueeze(1)\n", + "\n", + "in_data_points = tp.spaces.Points(complete_data, T*D_vec)\n", + "out_data_points = tp.spaces.Points(u_tensor_train, U)\n", + "\n", + "data_loader = tp.utils.PointsDataLoader((in_data_points, out_data_points), batch_size=len(in_data_points))\n", + "data_condition_fcn = tp.conditions.DataCondition(module=fcn_model,\n", + " dataloader=data_loader,\n", + " norm=2, use_full_dataset=True)\n", + "\n", + "# start training\n", + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate)\n", + "solver = tp.solver.Solver(train_conditions=[data_condition_fcn], optimizer_setting=optim)\n", + "\n", + "\n", + "trainer = pl.Trainer(gpus=1,\n", + " max_steps=train_iterations,\n", + " logger=False,\n", + " benchmark=True)\n", + " \n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Plot a solution from the test set:\n", + "plot_idx = 921 # <- can you change!\n", + "\n", + "fcn_input = torch.zeros((1, 60, 31))\n", + "fcn_input[:, :, :1] = t_tensor\n", + "fcn_input[:, :, 1:] = D_tensor_test[plot_idx].squeeze(-1).unsqueeze(0)\n", + "\n", + "fcn_model_out = fcn_model(tp.spaces.Points(fcn_input, T*D_vec)).as_tensor.detach()[0]\n", + "u_model = deepOnet(tp.spaces.Points(t_tensor, T), D_tensor_test[plot_idx]).as_tensor[0]\n", + "ref_solution = u_tensor_test[plot_idx]\n", + "\n", + "plt.figure(0, figsize=(14, 4))\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(t_tensor[::2], complete_data[plot_idx, 0, 1:])\n", + "plt.title(\"D(t)\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(t_tensor, u_model.detach())\n", + "plt.plot(t_tensor, fcn_model_out, linestyle=\"--\")\n", + "plt.plot(t_tensor, ref_solution)\n", + "plt.title(\"Solution\")\n", + "plt.legend([\"DeepONet\", \"FCN\", \"Real Solution\"])\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(t_tensor, torch.abs(fcn_model_out- u_model.detach()))\n", + "plt.title(\"Absolute Difference between FCN and DeepONet\")\n", + "plt.xlabel(\"t\")\n", + "plt.grid()\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bosch", + "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.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 14d80952dcc1f1563673fa53eb5b8c1fc69c2ffa Mon Sep 17 00:00:00 2001 From: Tom Freudenberg Date: Thu, 13 Jul 2023 09:03:14 +0200 Subject: [PATCH 29/30] Update to V.1.0.1 Signed-off-by: Tom Freudenberg --- CHANGELOG.rst | 6 +++--- setup.cfg | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 328bae43..698254d4 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -10,6 +10,6 @@ First official release of TorchPhysics on PyPI. Version 1.0.1 ============= - - Updated documentation and error messages. - - Simplyfied creation/definition of DeepONets. - - Add evalution of the DeepONet for discrete inputs. \ No newline at end of file + - Updated documentation and error messages + - Simplyfied creation/definition of DeepONets + - Add more evalution types for the DeepONet \ No newline at end of file diff --git a/setup.cfg b/setup.cfg index 098e8697..14129f83 100644 --- a/setup.cfg +++ b/setup.cfg @@ -6,7 +6,7 @@ name = torchphysics description = PyTorch implementation of Deep Learning methods to solve differential equations author = Nick Heilenkötter, Tom Freudenberg -version = 1.0.0 +version = 1.0.1 author_email = nick7@uni-bremen.de, tomfre@uni-bremen.de license = Apache-2.0 long_description = file: README.rst From ac15ec1fbb2ae52e799da9a411a37697ba63672e Mon Sep 17 00:00:00 2001 From: nick7 Date: Thu, 13 Jul 2023 14:04:57 +0200 Subject: [PATCH 30/30] ignore weight in metric logging --- src/torchphysics/solver.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/torchphysics/solver.py b/src/torchphysics/solver.py index 67838fe3..6ab24545 100644 --- a/src/torchphysics/solver.py +++ b/src/torchphysics/solver.py @@ -82,9 +82,9 @@ def on_train_start(self): def training_step(self, batch, batch_idx): loss = torch.zeros(1, requires_grad=True, device=self.device) for condition in self.train_conditions: - cond_loss = condition.weight * condition(device=self.device, iteration=self.n_training_step) + cond_loss = condition(device=self.device, iteration=self.n_training_step) self.log(f'train/{condition.name}', cond_loss) - loss = loss + cond_loss + loss = loss + condition.weight*cond_loss self.log('train/loss', loss) self.n_training_step += 1 @@ -93,7 +93,7 @@ def training_step(self, batch, batch_idx): def validation_step(self, batch, batch_idx): for condition in self.val_conditions: torch.set_grad_enabled(condition.track_gradients is not False) - self.log(f'val/{condition.name}', condition.weight * condition(device=self.device)) + self.log(f'val/{condition.name}', condition(device=self.device)) def configure_optimizers(self): optimizer = self.optimizer_setting.optimizer_class(