diff --git a/.github/workflows/docs-gh-pages.yml b/.github/workflows/docs-gh-pages.yml index fa1940d3..eff0dbfd 100644 --- a/.github/workflows/docs-gh-pages.yml +++ b/.github/workflows/docs-gh-pages.yml @@ -22,6 +22,7 @@ concurrency: jobs: build-docs: + if: github.repository == 'boschresearch/torchphysics' runs-on: [ubuntu-latest] container: python:3.10-bookworm steps: @@ -41,6 +42,7 @@ jobs: # Deployment job deploy-docs: + if: github.repository == 'boschresearch/torchphysics' environment: name: github-pages url: ${{ steps.deployment.outputs.page_url }} diff --git a/AUTHORS.rst b/AUTHORS.rst index af934369..1808e59f 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -5,3 +5,4 @@ Contributors * Nick Heilenkötter, nheilenkoetter * Tom Freudenberg, TomF98 * Daniel Kreuter, dkreuter +* Janek Gödeke, kenaj123 diff --git a/CHANGELOG.rst b/CHANGELOG.rst index b5a1900d..edcde01a 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -17,3 +17,17 @@ Version 1.0.1 Version 1.0.2 ============= - Test for python versions up to 3.10 + + +Version 1.1.0 +============= + - Rework of operator learning functionalities: + - Simplification of function spaces + - Restructuring of function set class (distinguishing between continuous and discrete functions) + - Addition of function samplers + - Generalization of operator training conditions + - Rework of DeepONet and FNO implementation, to make them compatible with the above changes + - Added PCANN and corresponding data analysis tools (PCA) + - Simplified saving and loading of neural networks + - Added discrete differential operators + - Updated operator learning examples diff --git a/README.rst b/README.rst index d5640d1f..10b62d2e 100644 --- a/README.rst +++ b/README.rst @@ -8,14 +8,16 @@ You can use TorchPhysics e.g. to - solve ordinary and partial differential equations - train a neural network to approximate solutions for different parameters - solve inverse problems and interpolate external data +- learn function operators mapping functional parameters to solutions 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]_ +- Physics-informed neural networks (PINN) [1]_ +- The Deep Ritz method [2]_ +- DeepONets [3]_ and physics-informed DeepONets [4]_ +- Fourier Neural Operators (FNO) [6]_ and physics-informed FNO +- Model order reduction networks (PCANN) [7]_ We aim to also include further implementations in the future. @@ -50,7 +52,7 @@ Some built-in features are: - pre implemented fully connected neural network and easy implementation of additional model structures - sequentially or parallel evaluation/training of different neural networks -- normalization layers and adaptive weights [6]_ to speed up the training process +- normalization layers and adaptive weights [5]_ to speed up the training process - powerful and versatile training thanks to `PyTorch Lightning`_ - many options for optimizers and learning rate control @@ -154,8 +156,9 @@ TorchPhysics uses an Apache License, see the LICENSE_ file. Bibliography ============ .. [1] Raissi, Perdikaris und Karniadakis, “Physics-informed neuralnetworks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations”, 2019. -.. [2] Bu and Karpatne, “Quadratic Residual Networks: A New Class of Neural Networks for Solving Forward and Inverse Problems in Physics Involving PDEs”, 2021 -.. [3] E and Yu, "The Deep Ritz method: A deep learning-based numerical algorithm for solving variational problems", 2017 -.. [4] Lu, Jin and Karniadakis, “DeepONet: Learning nonlinear operators for identifying differential equations based on the universal approximation theorem of operators”, 2020 -.. [5] Wang, Wang and Perdikaris, “Learning the solution operator of parametric partial differential equations with physics-informed DeepOnets”, 2021 -.. [6] McClenny und Braga-Neto, “Self-Adaptive Physics-Informed NeuralNetworks using a Soft Attention Mechanism”, 2020 +.. [2] E and Yu, "The Deep Ritz method: A deep learning-based numerical algorithm for solving variational problems", 2017 +.. [3] Lu, Jin and Karniadakis, “DeepONet: Learning nonlinear operators for identifying differential equations based on the universal approximation theorem of operators”, 2020 +.. [4] Wang, Wang and Perdikaris, “Learning the solution operator of parametric partial differential equations with physics-informed DeepOnets”, 2021 +.. [5] McClenny und Braga-Neto, “Self-Adaptive Physics-Informed NeuralNetworks using a Soft Attention Mechanism”, 2020 +.. [6] Zong-Yi Li et al., "Fourier Neural Operator for Parametric Partial Differential Equations", 2020 +.. [7] Kaushik Bhattacharya et al., "Model Reduction And Neural Networks For Parametric PDEs", 2021 \ No newline at end of file diff --git a/examples/deeponet/inverse_ode.ipynb b/examples/deeponet/inverse_ode.ipynb deleted file mode 100644 index 3d877c17..00000000 --- a/examples/deeponet/inverse_ode.ipynb +++ /dev/null @@ -1,465 +0,0 @@ -{ - "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$. 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 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", - "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 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, 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, output_space=F, output_neurons=50)" - ] - }, - { - "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 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 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": "6df74512dbe940048c789d28e5b70794", - "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": "bdccd39ed3154e2c8fc1240e65c0b356", - "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(devices=1, accelerator=\"gpu\",\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=10000, \n", - " logger=False, \n", - " enable_checkpointing=False)\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": "8ec664fa457e48b195d1f8f19aee774c", - "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": "113e3bc6b95c4f4798317b9d63eed528", - "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(devices=1, accelerator=\"gpu\",\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=1000, \n", - " logger=False, \n", - " enable_checkpointing=False)\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": "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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 = 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 -} diff --git a/examples/deeponet/ode.ipynb b/examples/deeponet/ode.ipynb deleted file mode 100644 index c983f464..00000000 --- a/examples/deeponet/ode.ipynb +++ /dev/null @@ -1,418 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Physics-informed DeepONet: Solving a ODE for different right hand sides\n", - "In this notebook, we present an introduction to the physics-informed DeepONet [(paper)](https://arxiv.org/abs/2103.10974) utilities of TorchPhysics. \n", - "As an example, we try to learn the integral operator of 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$. \n", - "\n", - "The general structure of TorchPhysics still holds for DeepONet problems. But we need some new concepts to define training functions of $f$. Here we show, how to:\n", - "\n", - "- create a function space for different training functions\n", - "- define a DeepONet-neural-network consisting of trunk and branch net\n", - "\n", - "and some additional details one has to consider.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torchphysics as tp\n", - "import pytorch_lightning as pl" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Spaces \n", - "T = tp.spaces.R1('t') # input variable\n", - "U = tp.spaces.R1('u') # output variable\n", - "K = tp.spaces.R1('k') # parameter\n", - "F = tp.spaces.R1('f') # function output space name\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" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# Defining function set\n", - "Fn_space = tp.spaces.FunctionSpace(T_int, F)\n", - "\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)\n", - "\n", - "param_sampler = tp.samplers.RandomUniformSampler(K_int, n_points=40)\n", - "Fn_set_1 = tp.domains.CustomFunctionSet(Fn_space, param_sampler, f1)\n", - "Fn_set_2 = tp.domains.CustomFunctionSet(Fn_space, param_sampler, f2)\n", - "Fn_set_3 = tp.domains.CustomFunctionSet(Fn_space, param_sampler, f3)\n", - "Fn_set = Fn_set_1 + Fn_set_2 + Fn_set_3" - ] - }, - { - "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, 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, U, output_neurons=50)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# ODE condition\n", - "inner_sampler = tp.samplers.RandomUniformSampler(T_int, 1000)\n", - "\n", - "def ode_residual(u, t, f):\n", - " return tp.utils.grad(u, t) - f\n", - "\n", - "ode_cond = tp.conditions.PIDeepONetCondition(deeponet_model=model, \n", - " function_set=Fn_set, \n", - " input_sampler=inner_sampler, \n", - " name='ode_condition',\n", - " residual_fn=ode_residual)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "left_sampler = tp.samplers.RandomUniformSampler(T_int.boundary_left, 500)\n", - "\n", - "def initial_residual(u):\n", - " return u\n", - "\n", - "initial_cond = tp.conditions.PIDeepONetCondition(deeponet_model=model, \n", - " function_set=Fn_set, \n", - " input_sampler=left_sampler, \n", - " residual_fn=initial_residual)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "tags": [ - "outputPrepend" - ] - }, - "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 | 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 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 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": "f2349bee03f34d7f8758d4bb2f4eaedd", - "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": "e4d434a1dc5742bebbe7109a4abcead2", - "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([ode_cond, initial_cond], optimizer_setting=optim)\n", - "\n", - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=5000, \n", - " logger=False, \n", - " enable_checkpointing=False)\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: [2]\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": "2b2610116f574ffba78d4f60b66d25bb", - "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": "caf835a0baeb42b9b684c43b8eba01ce", - "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": "ae55eac3287f4806b3476dea0284c6d6", - "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.4, \n", - " optimizer_args={'max_iter':2, 'history_size': 100})\n", - "\n", - "# here now use grid points:\n", - "ode_cond.input_sampler = tp.samplers.GridSampler(T_int, n_points=4000).make_static()\n", - "initial_cond.input_sampler = initial_cond.input_sampler.make_static()\n", - "# also fix parameters for input functions and take some more:\n", - "Fn_set_1.parameter_sampler = Fn_set_1.parameter_sampler.make_static()\n", - "Fn_set_2.parameter_sampler = Fn_set_2.parameter_sampler.make_static()\n", - "Fn_set_3.parameter_sampler = Fn_set_3.parameter_sampler.make_static()\n", - "\n", - "\n", - "solver = tp.solver.Solver(train_conditions=[ode_cond, initial_cond], optimizer_setting=optim)\n", - "\n", - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=3000, \n", - " logger=False, \n", - " enable_checkpointing=False)\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": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "k0 = 1.16\n", - "def f(t):\n", - " return k0 * t**2\n", - "\n", - "def F(t):\n", - " return k0/3.0 * t**3\n", - "\n", - "model.fix_branch_input(f)\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": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAwq0lEQVR4nO3deVyU5f7/8dc17MhigiIIipZruOOSW5ilZLmklluae2Z62s+xc/qWxzqd+mm7Vu52ytBcc/dkQm7lbqlYpuCCuIIoqKxz/f4APagIIw5zMzOf5+PB4zH33Nfc9/ti4MPNdd9z3UprjRBCCPtnMjqAEEII65CCLoQQDkIKuhBCOAgp6EII4SCkoAshhINwNWrHgYGBOjw8vFSvvXz5MhUqVLBuoHJO+uwcpM/O4W76vGvXrvNa68pFrTOsoIeHh7Nz585SvTYuLo6oqCjrBirnpM/OQfrsHO6mz0qpY7dbJ0MuQgjhIKSgCyGEg5CCLoQQDsKwMfSi5OTkkJSURGZmZrHt/P39OXjwoI1SlQ+O3mdPT09CQ0Nxc3MzOooQdqtcFfSkpCR8fX0JDw9HKXXbdunp6fj6+towmfEcuc9aa1JSUkhKSqJmzZpGxxHCbpU45KKUmq2UOquU2n+b9Uop9alS6rBS6jelVLPShsnMzCQgIKDYYi4cj1KKgICAEv8zE0IUz5Ix9LlAdDHrHwVqF3yNAr64m0BSzJ2TvO9C3L0Sh1y01huVUuHFNOkB/Efnz8P7i1KqolIqWGt9ylohhRBlLys3j/MZ2ZxPzyL1chZXMzPJunqZ3KwrZGdexZxzFZM2o00uYHJFKxdcXFxx8/bFw6ciPp7u+Hi4UdHbjSq+Hvh7uckfahuzxhh6NeBEoeWkgufssqArpXj55Zf54IMPAJg8eTIZGRlMmDDhtq+Ji4vD3d2dNm3aWDXL3Llz2blzJ1OmTLHaNtPS0vj2228ZM2ZMqbexbNky6tSpQ4MGDayWS5S93DwzR1Muc/RMGqnJh8k8m4A59Sgel5PwzT6LX95FKql0KqtL1CUdT5VzR9tP116k48UlXYF92p+zKoB09ypkeQWh/ENwD6pDpWp1CK/iT83ACvh6yglwa7PpSVGl1Cjyh2UICgoiLi7uhvX+/v6kp6eXuJ28vDyL2pWGh4cHixcvZty4cQQEBJCVlUVWVlax+1u3bh0+Pj40bNjQajlyc3PJzMwkOzub9PR0q/U5KSmJKVOmMGjQoFJvY+HChURHRxMWFnbXeQrLzMy84WciIyPjlp8RR2etPmfnaRLTcrmSehLXi0fxu3KM4Nzj1OEED6mzmNT/bmyTgytppkpccfcjy7USF9xqct7dH7ObN7i4Y3L1QLm6o1zc0UqBNqN0HmgzOi8Pc24mKucKppwMXHKu4JKbQY3sC0Tk7sM/9wKmdA3pQBJk73ThmK7KFh3CSZdqpHrV5JJ3DfaeySHc34WKns5xJXVZ/Wxbo6CfBAr/ZocWPHcLrfV0YDpAZGSkvvmjrwcPHrToSo6yvOLD1dWVZ599lhkzZvCvf/0LDw8PcnJy8PX15dy5c4wePZrjx48D8PHHH1OtWjXmzJmDi4sLCxcu5JNPPmHIkCEkJCRw8eJFAgICiI2NpUOHDnTo0IFZs2YREBDAsGHDSEhIwNvbm+nTp9OoUSMmTJjAkSNHSEhIoHr16nTp0gV3d3d8fX1ZuHAhH374IStWrCAwMPB63tTU1Ntuy8fHh1dffRWAiIgIVq5cyTvvvENiYiLt27fnkUce4bHHHuPNN9/E19eXw4cP07FjRz7//HNMJhM+Pj5kZGQAsGjRIlauXMmoUaNYs2YNW7du5YMPPmDx4sXce++9Vvnee3p60rRp0+vL8pFwy53PyGLvn8c4G78FdXIH1TL20V8dxk9dAcCMiVTvUDLvaczZqvXxrXof3kG1UPeE4+YbTGWTi5V7UiAvFy6fhYtJZJ89REZSPH5n/qBl2hH8r+zG5WoeXIXU8z7sN9ck0aMuV4NbE1C/Pc1rh1IzsIJDDtuU1c+2NQr6cmCsUmo+0Aq4aI3x83+uOEB88qUi1+Xl5eHicuc/gA1C/Hir2/0ltnv++edp1KgRf/3rX294/oUXXuCll16iXbt2HD9+nC5dunDw4EFGjx59Q/GsW7cu8fHxJCYm0qxZMzZt2kSrVq04ceIEtWvXZty4cTRt2pRly5axYcMGBg8ezN69ewGIj49n8+bNeHl5MXfuXACWLl3KRx99xOrVq7nnnntuyPTWW2/ddltFee+999i/f//1NnFxcWzfvp34+Hhq1KhBdHQ0S5YsoU+fPkW+vk2bNnTv3p3HH3/8tm1E2cvONbM74TQJe2JxSYyj7pWddFSJuCiNGcX5CvdyKbgb3PcAvuFNMFWuR6Cbl+2DuriCXwj4heAe1pJKzQuty82CMwfYv2EBQaZU7j+1l7YZS3A5sYic4y78uvZe4lwiyAprR1jTTrSvWw1/bxmmKU6JBV0pFQNEAYFKqSTgLcANQGv9JbAa6AocBq4AQ8sqrK34+fkxePBgPv30U7y8/vdLsH79euLj468vX7p06foRbGHt27dn48aNJCYm8vrrrzNjxgwefPBBWrRoAcDmzZtZvHgxAA899BApKSlcupT/x6t79+437HPDhg3s3LmTxYsX31LMS9qWpVq2bEmtWrUA6N+/P5s3b5ZiXQ5dvJrDlr0HSN29jLCzcbQgntYqizxMnK0YwZla4whs8CDu1VtSxdPP6Lglc/WAas04H3aJiGtHq1np6OPbyIiPJTxxI03TluFyfAnpx7zYYo7gyD3t8Lr/UaKa3U+tyj6Gxi+PLLnKpX8J6zXwvNUSFSjuSNoWH7J58cUXadasGUOH/u/vk9ls5pdffsHT07PY13bo0IEvvviC5ORkJk6cyKRJk4iLi6N9+/Yl7vfmKTXvvfdeEhISOHz4MNWqVbM4v6urK2az+fpycdd43/wv7bXlws/LNeLGuHA5m807dnB57zJqp8YRrf7EpDQpHiGcD+tD5cZd8KoTRbCnv9FRrcPDF1X7Ye6p/XD+clYGeQkbydy7graJ64m+tAN+/ojdW+5jWoWOeDTuRVRkY8IDnWv63dtxjjMQpVCpUiWeeuopZs2adf25zp0789lnn11fvjZs4evre8MJy5YtW7J161ZMJhOenp40adKEadOm0aFDByD/CH7evHlA/pBHYGAgfn5FH1HVqFGDxYsX8+yzz3LgwIFb1t9uW+Hh4ezevRuA3bt3k5iYWGRWgO3bt5OYmIjZbGbBggW0a9cOyD9xffDgQcxmM0uXLr3evqhtCOvJzjUTu/sg86a8SeL7begW15V+adOp5gOnm72I+dktBLweT/VBn+PVqAc4SjEviocPLvW7Urn/F/i+fgie3cSlB/5GDT8Xnr06g8E/d+XMpw/x+aTxxMTu4sLlbKMTG0oKejFeeeUVzp8/f335008/ZefOnTRq1IgGDRrw5ZdfAtCtWzeWLl1KkyZN2LRpEx4eHoSFhdG6dWsgv+imp6dfvwpmwoQJ7Nq1i0aNGjF+/Hi++uqrYnPUq1ePmTNn8uSTT3LkyJEb1t1uW7179yY1NZX777+fKVOmUKdOHQACAgJo27YtERERvPbaawC0aNGCsWPHUr9+fWrWrMkTTzwB5I+3P/7447Rp04bg4ODr++zXrx+TJk2iadOmt+QRpReflML+PZvY8k5n2n7floHnPyHUO4/TLcaj/7KXqn/dQUiPCZiCI8ABTxSWSCkIboRfl78T8Op2GLuTjAdepY5PFmMuf0HvuEfY9v5jTJ3xJT/9fpo8sy55mw5G5Y+Y2F5kZKS++QYXBw8epH79+iW+1pHnNbmdsupzXFwckydPZuXKlVbf9p26+f13hqtcsnLziNu+h4tbZtEhYw1V1QUuugRw8b6ehHR4BteQRg5fvO/6fdYazhzg/JY5eB1cRIXcNE7qANa5PoRri2d4vH0rKlVwt1pea7jLG1zs0lpHFrWuXE3OJYSzOJV2hY1rF1Ll9695WO9EKUgKbMv2yh1o+eQr+LvIr6bFlIKqEQT2/gBy/03OwZW4b57FkDOLMP+8mPVbW5Bw79M8+HB37q9W0ei0ZUp+apxcVFSUwx8FlyeHklPZsXIWTZO+pq/pGJdcKnKy3rOEdnqO6pXCSYiLy7/UT5SOqztuDXtRuWEvSDvOhbjP6bDvG6ITx7F/2gd8fk8v7u8yjA71Qx3y+nb5yRGijGmt2XXoOEfWTqV96kIGqlTOetckpd3HBLQegJ+rh9ERHVPF6gT0fA+6/h9Xd35LyJbPGXPxQ04vmMPMCr0Jffg5Oje5FxeT4xR2KehClBGtNdsOJnJ81SSiM5YRqa5womIk6Q9PoUpEV4cfGy833Cvg1WYkXg+MIOfQj5jWvcfI1Jmkfj+fuWt7UKnj83RrWR9XF/u/RkQKuhBlYOfviSSsnEx0+hJaqyscC+qE+2N/J6xGkeeyhC0ohVvdh6lS92Hyjv1C7pp3GX56HulrlzAvtjtBXV6lc9PamOz4iF0KuhBWtPfwcf5cPpnOFxcSqa5wPKgjnj3+SY1qjY2OJgpxqdGaKqOXo0/9yuWV/+KZkwtIXb6K2euf4t6uLxIVUd0ux9jt/3+MMrBs2TKUUvz+++93tZ0hQ4awaNGiYtu8++67NyyXdgreCRMmMHny5FK99pq4uDgef/zxYtukpaXx+eefX19OTk6WaQKAxDNpxEx5g7Cv2/Dkpa9Iq9yCrOFxVB+zDHcp5uWWCm5M1ZHfkTcijpygJoy4Opv6ix5k2odvsCvxjNHx7pgU9CLExMTQrl07YmJiynxfNxf0rVu3lvk+78bNBT0kJKTEP1qOLO1yFvO//hL9eWv6n/+MqxXrcHXIemqMXY5HWNOSNyDKBZfQpgSNWUXu4JW4VKrB6PQp3DOnA9NmTCEp9bLR8SwmBf0mGRkZbN68mVmzZjF//vzrz1/7IECfPn2oV68eAwcO5NqHsiZOnEiLFi2IiIhg1KhR3PxhrQ0bNtCzZ8/ryz/88ANPPPEE48eP5+rVqzRp0oSBAwcC4OPzvwmH3n//fRo2bEjjxo156623AJgxYwYtWrSgcePG9O7dmytXrhTbn4ULFxIREUHjxo2vTz2QmZnJ0KFDadiwIU2bNiU2NvaW1918xB8REcHRo0cZP348R44coUmTJrz22mscPXqUiIiIYrc7d+5cevXqRXR0NLVr175lFkt7lJ1rZtmqFfw5KYp+R/6Gj6c7aT2/JvTFH/EKb2F0PFFKrrXaU/kvcWQ+FYN/BU+ePfkPjn3chblLV3M5K9foeCUqv2Poa8bD6X1FrvLKyy3dtbpVG8Kj7xXb5Pvvvyc6Opo6deoQEBDArl27aN48f87PPXv2cODAAUJCQmjbti1btmyhXbt2jB07ljfffBOAQYMGsXLlSrp163Z9mx07dmTMmDGcO3eOypUrM2fOHIYNG0a3bt2YMmVKkdPdrlmzhu+//55t27bh7e3NsWPHAOjVqxcjR44E4I033mDWrFmMGzfutv2ZOHEi69ato1q1aqSlpQEwdepUlFLs27eP33//nc6dO3Po0CGLvoU3T7979OjR6+uK2+7evXvZs2cPHh4e1K1bl3Hjxln9Bhm28vNvv3Nh+T/ombueSyZ/Trd9l6pRz8r1445CKTwbdMWz7iOkbfySJpvep/XeASzZ1wXPh9/g8Qciyu34uhyh3yQmJoZ+/foB+XOWFB52admyJaGhoZhMJpo0aXK9mMXGxtKqVSsaNmzIhg0bbplESynFoEGD+Oabb0hLS+Pnn3/m0UcfLTbH+vXrGTp0KN7e3kD+ZGEA+/fvp3379jRs2JB58+YVOWFXYW3btmXIkCHMmDGDvLw8IH/K3aeffhrInyemRo0aFhf04hS33U6dOuHv74+npycNGjS4/gfKnpy+cJmYqROov/ghOufGcrzeCPz+up+qnZ6XYu6IXNyo2HEcFV79jZQGg+ll/i8d1nVm9sdvcPjMnU1RbSvl96ewmCPpq2U0r0lqaiobNmxg3759KKXIy8tDKcWkSZOA/NvTXePi4nL9NnFjxoxh586dhIWFMWHChCKnmh06dCjdunXD09OTJ598ElfX0n3rhwwZwrJly2jcuDFz584t8TZWX375Jdu2bWPVqlU0b96cXbt2WbSfO5l+1xJFfe/sRU6emVVrV3Hf9jfprxI4UTESr76fUj2k5JulCAfgXYkqfT/FfHo0Vxe+yPCUKeydupb/NJ3AU493xdOtjO72VApyhF7IokWLGDRoEMeOHePo0aOcOHGCmjVrsmnTptu+5lqhCwwMJCMj47YnCENCQggJCeGdd965YY51Nzc3cnJuvRnvI488wpw5c66PkaempgL5k3QFBweTk5Nzfdrc4hw5coRWrVoxceJEKleuzIkTJ26YcvfQoUMcP36cunXr3vC6O5l+9xpLtmtvfj18nLXvD6D79kFUc03jfJfPCXtxPR5SzJ2OqWoDqo5dR3rXqdzrdp4Bewez9P1hbIovP/9tSkEvJCYm5vrUsdf07t272KtdKlasyMiRI4mIiKBLly7X70pUlIEDBxIWFnbDjIKjRo2iUaNG10+KXhMdHU337t2JjIykSZMm1+dhf/vtt2nVqhVt27alXr16Jfbptddeo2HDhkRERNCmTRsaN27MmDFjMJvNNGzYkL59+zJ37twbjqCv9dvS6XevsWS79uJqdh4x38yk8tdRdM1ex/E6g6n42l4CHxgon/B0Zkrh2/JpfF/Zw/naT9I/dxk1FzzEjFlfcPHKrQdmNqe1NuSrefPm+mbx8fG3PFeUS5cuWdSuvHn++ef1zJkzS/Vae+3znbj5/Y+NjTUkx44Df+p1E7tp/ZafPv1uI51x5Geb7duoPhvJnvucdWSzPvdeE63f8tMrJ3TXsXv+sOh1d9NnYKe+TV2VI3Qbad68Ob/99tv1k4ai/MnIymXBnE8IX9CRh/I2c6LROIJe206FWq2NjibKKfdabQl8ZRtnm75AtN5IvaWdmTHTuKP18ntS1MFYejJSGGPX7wlcWDiOvnmbSa5Qn5wB0wgLlU94Cgu4ulOlx0RymvXENWYEI5PGs2LSOvx6TuLBxrVtGqXcHaFrg+6gJIxl1PuenWtmwYL/EBLTiai8nznZ7BVCXtmMlxRzcYfcwpoR+PLPnG0yjq76J+os6cycr2dzNTvPZhnKVUH39PQkJSVFirqT0VqTkpKCp6enTfd7JPksayY/Q9+D4zB5+pI99AeqdX9TrikXpefqQZWe75A37AfcvPwYeuQlVkwaxoHjZ22ze5vsxUKhoaEkJSVx7ty5YttlZmba/JffaI7eZ09PT0JDQ22yL601K/+7jnpbX6GHSuLYfYOo0XcSuHnZZP/C8blXjyTw5Z85tehVnjo0jwOz9rKg1Qc8Gd2pTKfnLVcF3c3NjZo1a5bYLi4ujqZNnWviI2fsc1lIu5zFqtlv0+f8F1xx9SetxwJqNIo2OpZwRO7eBA/4nIxfo6nx/fPU2taf2X+M5vGhfy+zXZarIRchytJvfx5l9wc9GJjyGWcCW1Px5e1UlGIuyphP4+5UeHE7Fys3Z8TFT4n/uDt/nkkrk31JQRcOT2vNslUrqPjNI3Qwb+dki9ep/vwKVIVAo6MJJ6H8gqk6ZjXn2/wf7dlNgwu3znBqDeVqyEUIa0u7nMXaWRPolTKNdLcAMvuupFrt0t1ERIi7YjIR2PlVzI0eJefg6TLZhRR04bD2HTlB6rzh9DNv41jlKKoPm4PyrmR0LOHkTFXvh9+Lv/CjtKSgC4e0Nu4naseOpr46zcmWb1Dj0VdlDhbh8KSgC4eSk2dm4Tdf0i1hImYXd648uYRq9TsaHUsIm5CCLhzGuYtX2Dj9ZQZcjiHZpwFVhi/AtVJ1o2MJYTMWXeWilIpWSv2hlDqslBpfxPrqSqlYpdQepdRvSqmu1o8qxO3tO3yMPz9+jN6XYzhWvRchL8ZKMRdOp8QjdKWUCzAVeARIAnYopZZrreMLNXsD+E5r/YVSqgGwGggvg7xC3GLdT5uou2EE9dR5TrV7lxqdxsh4uXBKlgy5tAQOa60TAJRS84EeQOGCrgG/gsf+QLI1QwpRFLNZ893Cb3g0/q/g4sbVvssIrtve6FhCGEaVNBGWUqoPEK21HlGwPAhopbUeW6hNMPBf4B6gAvCw1vqW+WKVUqOAUQBBQUHN58+fX6rQGRkZ+Pj4lOq19kr6fKOsPE3izlWMuDKL067VONr8DXK9q9o4ofXJ++wc7qbPHTt23KW1jixy5e3ufHHtC+gDzCy0PAiYclObl4FXCh4/QP7Ru6m47RZ1xyJL2fMdTkpL+vw/Zy5k6KX/Hqz1W376+KePavPVNNsGK0PyPjuHsrpjkSVDLieBsELLoQXPFTYciC74A/GzUsoTCARsM2ekcBoHj54k9T+D6GnexfHag6ne7yOZ7laIApZc5bIDqK2UqqmUcgf6ActvanMc6ASglKoPeAJl81Eo4bQ27fwV05xoWpn3kNzuX1Qf+JkUcyEKKfG3QWudq5QaC6wDXIDZWusDSqmJ5B/6LwdeAWYopV4i/wTpkIJ/DYSwilU/bqDpxuFUNF0l44kYQmSWRCFuYdHhjdZ6NfmXIhZ+7s1Cj+OBttaNJkT+OZ6Fi+fTZd/LmF09Uc+soWJ1mRdeiKLI9Lmi3Moza2LmfEKPfWPJ9AjEZ0wsXlLMhbgtGYAU5dLV7DyOblvC0MyvSfZrSLXnvpeZEoUogRR0Ue6kZmSycepzDM9awrGgTtQYOU/u9ymEBaSgi3IlKeUS+794hp65G9hd8VGajZ4HJhejYwlhF6Sgi3Ij4XQKx6YPINr8C0lNXuKS/4NSzIW4A3JSVJQLB4+d4uy0nnQ0/8KpNhMI7TlBJtgS4g7JEbow3N5DR1Hf9qEFRzjb6SOC2w8zOpIQdkkKujDU9n0H8Vv0FLVUMhcem0GVFn2MjiSE3ZKCLgyzaccuwlYOIEilcbnPtwRGdDE6khB2TQq6MMT6zVu5/4eB+JqyyR24lHvua2N0JCHsnhR0YXNr4jbRNHYQ3i5mTENW4V29idGRhHAIUtCFTa2J/YnmcYPxcAGP4avwqNbQ6EhCOAy5bFHYzKofNxAZ9zTuLiY8R66RYi6ElckRurCJlT/8wAObh2Jydcdr5Go8qtYzOpIQDkcKuihzK9etpc3W4eDqhfeza/CoUtvoSEI4JBlyEWVqxdo1tNs6DO3qTYXR66SYC1GG5AhdlJlla9fy4M8jyHXzwW/0f3EPDDc6khAOTQq6KBMr1m+g3c8j0a5e+I9eh5sUcyHKnBR0YXVrf9pMq01DcXV1xfvZNbgF1jQ6khBOQQq6sKoft26j8YZBeLhoPIevxF3GzIWwGSnowmp+2r6LuusG4GPKwXXYKjxC7jc6khBORQq6sIotu38jfFV/7jFdRQ1ZgVdoY6MjCeF05LJFcde27ztI8Pd9qawuoZ9egneN5kZHEsIpSUEXd2XX7wlUXPQkISqF3P7f4XNva6MjCeG0pKCLUjuQmIxLzFOEq1Nk9pmHX90ORkcSwqlJQRelcuR0Cpe+6ktDdYSMbjOoGPGI0ZGEcHpS0MUdS07N4Pj0ATzAb6Q8NJlKzXsZHUkIgRR0cYdSM7LY+8UzdDT/wqnWb1Klw3CjIwkhCkhBFxbLyMoldupzdM1Zz8mGYwmOfsXoSEKIQqSgC4tk5eaxYupr9L66mBP3DqBar3eMjiSEuIkUdFGi3DwzC6e9Q/9Lszle7THCBk4FpYyOJYS4iUUFXSkVrZT6Qyl1WCk1/jZtnlJKxSulDiilvrVuTGEUrTXfzp3KgLMfcTywPdWHfQUmOQ4Qojwq8aP/SikXYCrwCJAE7FBKLddaxxdqUxt4HWirtb6glKpSVoGFbcUsmk/f4//ktF8E1Ud9By5uRkcSQtyGJYdaLYHDWusErXU2MB/ocVObkcBUrfUFAK31WevGFEZYvn4Dj+1/mYuewQSP/h7cvY2OJIQohtJaF99AqT5AtNZ6RMHyIKCV1npsoTbLgENAW8AFmKC1XlvEtkYBowCCgoKaz58/v1ShMzIy8PHxKdVr7ZWt+3wo6QyP/fk6XqY8DrZ4nxzvqjbb9zXyPjsH6fOd6dix4y6tdWRR66w126IrUBuIAkKBjUqphlrrtMKNtNbTgekAkZGROioqqlQ7i4uLo7SvtVe27POeP4/xYOw47jFdQQ1bQ9uwpjbZ783kfXYO0mfrsWTI5SQQVmg5tOC5wpKA5VrrHK11IvlH63JnAzt05HQKufP6U0slk9vnP3gZVMyFEHfOkoK+A6itlKqplHIH+gHLb2qzjPyjc5RSgUAdIMF6MYUtnL10hcQZg2nBAS52/hi/+zsbHUkIcQdKLOha61xgLLAOOAh8p7U+oJSaqJTqXtBsHZCilIoHYoHXtNYpZRVaWF9GVi6bP3+Oh/M2k9zidQLbDDI6khDiDlk0hq61Xg2svum5Nws91sDLBV/CzuTkmfn+i38wMHMZJ+oMJqzr34yOJIQoBfmEiJPTWvPtnM8YmPYlJ6p2JqzfJ/IpUCHslBR0Jzd/6VL6nnibZN9GhA3/Wj4FKoQdk99eJ/bfzdt4+NcXyHCvTPCzS8DN0+hIQoi7YK3r0IWd2fXHUWr9MBQvkxn3EctQPpWNjiSEuEtS0J3Q0TNp5MY8TQ11hqy+i3APqmt0JCGEFciQi5NJu5zFgRnDacU+0jpNxqdeR6MjCSGsRAq6E8nONbP6y7/xWO56TjYeR+X2Q42OJISwIinoTkJrzYK5nzAgfQ4nQh+jWs+3jY4khLAyKehOYvH3S3nqxL846duYsGdmy7XmQjggKehO4MefdxC15wUuuVcmZLRcniiEo5KrXBzc3iNJVFs7DE+TGfcRS1EVAo2OJIQoI3KE7sBOXrhM2jdDuE8lYe4zB/egekZHEkKUISnoDupKdi6bp71AlN7BhXYTZCpcIZyAFHQHZDZrFsz6gL6ZCzl5b18qd/qL0ZGEEDYgBd0Bfff9UgacnkRyxUiqDZgqV7QI4SSkoDuY2G17eGjvS6S7VyZ45Hfg4mZ0JCGEjchVLg4k/vhpqqweio8pC9dhq1AVAoyOJISwITlCdxDnLmVyau5Q6qujZPecgXtwhNGRhBA2JgXdAWTl5vHjtFfoZN7KmVb/oGLjbkZHEkIYQAq6ncufo2UK/S5/w4nqTxAc/arRkYQQBpGCbueWrP0vfU78i2TfhoQNniZXtAjhxKSg27Gt+/4k8pexZLv6UHXEQnD1MDqSEMJAcpWLnTp27hJ68XCCVSp5A1di8g82OpIQwmByhG6HrmTnsm3mi7TlV9Ifeh+vWg8YHUkIUQ5IQbczWmti5nzMU1mLSa49gIAOI4yOJIQoJ6Sg25lFq9cyIPl9Tvk3IaTvJ0bHEUKUI1LQ7cjWfYdovX0cmW5+VB2xAFzdjY4khChH5KSonTh3OYfQuGEEqTTyBq5C+VY1OpIQopyRI3Q7cCU7l9xdc3iAfVzq9D5eNVsZHUkIUQ5JQS/ntNZ8N/tD+ptXkVR7EIHthxsdSQhRTllU0JVS0UqpP5RSh5VS44tp11sppZVSkdaL6NyWrF5D31OTOOJRn9B+HxkdRwhRjpVY0JVSLsBU4FGgAdBfKdWgiHa+wAvANmuHdFY/7/+Tltv/QqabP6ea/U3mNhdCFMuSI/SWwGGtdYLWOhuYD/Qoot3bwPtAphXzOa0TKRnkLRpJkLqA58B55HrcY3QkIUQ5Z8lVLtWAE4WWk4AbzsoppZoBYVrrVUqp1263IaXUKGAUQFBQEHFxcXccGCAjI6PUr7UH2XmapK3fMIw97KzxLBnHrjp8n4sifXYO0mfruevLFpVSJuBDYEhJbbXW04HpAJGRkToqKqpU+4yLi6O0r7UHs+dMZ0juYpJrPkHkM++DUg7f56JIn52D9Nl6LBlyOQmEFVoOLXjuGl8gAohTSh0FWgPL5cRo6az8aSu9jk7gfIX7CBnwuUyHK4SwmCUFfQdQWylVUynlDvQDll9bqbW+qLUO1FqHa63DgV+A7lrrnWWS2IEdOHaG8A1jcDNBwLDvwN3b6EhCCDtSYkHXWucCY4F1wEHgO631AaXURKVU97IO6CzSrmST+J/niFCJ5PWchktgLaMjCSHsjEVj6Frr1cDqm5578zZto+4+lnMxmzVLZ77L0LwfOd14HFXlnqBCiFKQT4qWA98tX86AlM9IDniAqj3+aXQcIYSdkoJusK37DtFuz8tcdgsgeNg8MLkYHUkIYadktkUDJaWkoxePoIpKw/z0GlSFAKMjCSHsmByhGyQrN48tM1+lLb9yqeO/8QxvaXQkIYSdk4JukPnzZtH36nySwnsR2GGk0XGEEA5ACroB1mzaTo+ECZz2rkPoQPnwkBDCOmQM3cYOJp0neP1zuJs0PkNjwM3L6EhCCAchR+g2lJ6Zw/65L9JEHSbn8c9wrXyf0ZGEEA5ECrqNaK2J+WoqT+au4Ez9Ifg372N0JCGEg5GCbiNLN2ymX/J7nPGNIKj3JKPjCCEckBR0G9h39DR1N47F5OJK5aHzwNXd6EhCCAckBb2MXbyaw5Fv/sL96ij0/BJTpXCjIwkhHJQU9DKktWbhnA/pmbuO0w2fxafR40ZHEkI4MCnoZWjxf2Ppf+YDTvs3pWrPfxkdRwjh4KSgl5E9Cck02jIOs4snQcPmgYub0ZGEEA5OCnoZSLuSTfK857nPdBJT75ko/2pGRxJCOAEp6FZmNmuWzHqfx/I2cLbpX6hwf2ejIwkhnIQUdCtbvGYd/c9/SnKlllTt9pbRcYQQTkQKuhXt+vM4zba/RLarD8FDv5GbVQghbEoKupWkpGdyPmYM4eo0rn3noHyDjI4khHAyUtCtwGzWfD/nPbqYN3E+8lUq1IkyOpIQwglJQbeCBavWMiBlCskBbQjq+rrRcYQQTkoK+l3a/scJIne8QparL8FD5oJJvqVCCGNI9bkLKRlZnFnwF+41JeP+1EwZNxdCGEoKeilprVk050O6mTeQ0nQcXnU7GR1JCOHkpKCX0sL/xjHw/MecqdiMyo/L9eZCCONJQS+F3xJPE7H1BXBxp8rQr8FFbs0qhDCeFPQ7dCkzhz/nvUQDdQx6foHyDzU6khBCAFLQ74jWmvlfTaV37mrO3D9c5jcXQpQrUtDvwIqffqFv8vuc8W1A0BPvGR1HCCFuIIO/FvrjZCphseNwM4HvkG/lvqBCiHLHoiN0pVS0UuoPpdRhpdT4Ita/rJSKV0r9ppT6USlVw/pRjXM1O4+9X71CU/UnOY99jCmgptGRhBDiFiUWdKWUCzAVeBRoAPRXSjW4qdkeIFJr3QhYBPw/awc1Usy3s+mbvYRT9/XHP7Kv0XGEEKJIlhyhtwQOa60TtNbZwHygR+EGWutYrfWVgsVfAIe59GPdL3vpnjiRs973Edz3I6PjCCHEbSmtdfENlOoDRGutRxQsDwJaaa3H3qb9FOC01vqdItaNAkYBBAUFNZ8/f36pQmdkZODj41Oq196Jsxk5VN/+Jo1NR9gTOZlsn+plvs/bsVWfyxPps3OQPt+Zjh077tJaRxa1zqonRZVSTwORwINFrddaTwemA0RGRuqoqKhS7ScuLo7SvtZS2blmFn4wltameFIf+Zg2bQeX6f5KYos+lzfSZ+cgfbYeSwr6SSCs0HJowXM3UEo9DPwDeFBrnWWdeMaJWfgtT1/5luQa3QlpM8ToOEIIUSJLxtB3ALWVUjWVUu5AP2B54QZKqabANKC71vqs9WPa1sY9B+ny+xtc8AwlZODnoJTRkYQQokQlHqFrrXOVUmOBdYALMFtrfUApNRHYqbVeDkwCfICFKr/4Hddady/D3GXmVNoV+H4MASod89PLwMPX6EhCCGERi8bQtdargdU3PfdmoccPWzmXIXLzzKyd/U+Gspvz7d8mMKyJ0ZGEEMJi8tH/Qr5dsZoBF2dyKuhBAh8aZ3QcIYS4I1LQC2z7/QRtdr9Gpps/wYNny7i5EMLuSEEHLlzO5tR3L1HLdAr3J2dAhUCjIwkhxB1z+oKePyXuZ/Q0/0BK49FyKzkhhN1y+oK+JG4bA85M5qxfBJW7v210HCGEKDWnnj73j+QL1Ij7C+4m8B38Nbi4GR1JCCFKzWmP0DNz8tj+1etEqj/IeXQypsBaRkcSQoi74rQFfd53MQzInM/p8J74tRxodBwhhLhrTlnQY/ceIvrQm6R5VqNq/ylGxxFCCKtwujH002lXyVs2liCVhnngAvlovxDCYTjVEXqeWbNy7r95mG1cfOB13Ku3MDqSEEJYjVMV9O/W/MDAC19wOvABAh55xeg4QghhVU5T0H9NPE3TbS+T6+pN0OA5YHKargshnIRTVLX0zBz+nPcy9UwnMD3xBcov2OhIQghhdU5R0Bd8M50+uas4U38oFSK6Gh1HCCHKhMMX9DVbd9PrxLucrVCHoN7vGx1HCCHKjENftnjs3CXuWTcOb1MOroO/BlcPoyMJIUSZcdgj9Jw8Mz/N/T9aq/1c7fRvXIPqGR1JCCHKlMMW9JglS+if8TWnqkVzT9thRscRQogy55AFfVt8IlH7x5PhXpngp6fJ3YeEEE7B4cbQUzOyuLBwHJEqhZx+K8GrotGRhBDCJhzqCF1rzdK5k4nWm0iJfAnPe9saHUkIIWzGoQr6sh830vfcp5yq2JwqXf9hdBwhhLAphynov588z32bXgQXN6oO+QpMLkZHEkIIm3KIgp6Zk8dvX71KQ5WAudunqIphRkcSQgibc4iCPj9mLk9lLyX5vv74Ne1ldBwhhDCE3Rf02F0HeOzIPznnWZOQpz40Oo4QQhjGri9bPJV2GbcVz+OvrqAGrwJ3b6MjCSGEYez2CD3PrPlh9j9pxx4udZiAW0hDoyMJIYSh7LagL1q5ir4XZ3EyqCOBHZ83Oo4QQhjOLgv6sZTLRO56jauuFQkZPFM+2i+EEFhY0JVS0UqpP5RSh5VS44tY76GUWlCwfptSKtzqSQukZ+bgv28GNdUpXJ+cgaoQWFa7EkIIu1JiQVdKuQBTgUeBBkB/pVSDm5oNBy5ore8DPgLK7E4SsYun0ZNYzjR6Dp96D5XVboQQwu5YcoTeEjistU7QWmcD84EeN7XpAXxV8HgR0EmpshkHiW5RnwTfFgT3mFgWmxdCCLultNbFN1CqDxCttR5RsDwIaKW1Hluozf6CNkkFy0cK2py/aVujgFEAQUFBzefPn1+q0BkZGfj4+JTqtfZK+uwcpM/O4W763LFjx11a68ii1tn0OnSt9XRgOkBkZKSOiooq1Xbi4uIo7WvtlfTZOUifnUNZ9dmSIZeTQOHJUUILniuyjVLKFfAHUqwRUAghhGUsKeg7gNpKqZpKKXegH7D8pjbLgWcKHvcBNuiSxnKEEEJYVYlDLlrrXKXUWGAd4ALM1lofUEpNBHZqrZcDs4CvlVKHgVTyi74QQggbsmgMXWu9Glh903NvFnqcCTxp3WhCCCHuhF1+UlQIIcStpKALIYSDkIIuhBAOosQPFpXZjpU6Bxwr5csDgfMltnIs0mfnIH12DnfT5xpa68pFrTCsoN8NpdTO231SylFJn52D9Nk5lFWfZchFCCEchBR0IYRwEPZa0KcbHcAA0mfnIH12DmXSZ7scQxdCCHErez1CF0IIcRMp6EII4SDKbUEvT/cxtRUL+vyyUipeKfWbUupHpVQNI3JaW0n9LtSut1JKK6Xs/hI3S/qslHqq4P0+oJT61tYZrc2Cn+/qSqlYpdSegp/xrkbktBal1Gyl1NmCGwAVtV4ppT4t+H78ppRqdtc71VqXuy/yZ3U8AtQC3IFfgQY3tRkDfFnwuB+wwOjcNuhzR8C74PFz9t5nS/td0M4X2Aj8AkQandsG73VtYA9wT8FyFaNz26DP04HnCh43AI4anfsu+9wBaAbsv836rsAaQAGtgW13u8/yeoReru5jaiMl9llrHau1vlKw+Av5Nxuxd5a81wBvk3/z8UxbhisjlvR5JDBVa30BQGt91sYZrc2SPmvAr+CxP5Bsw3xWp7XeSP504rfTA/iPzvcLUFEpFXw3+yyvBb0acKLQclLBc0W20VrnAheBAJukKxuW9Lmw4eT/dbd3Jfa74F/RMK31KlsGK0OWvNd1gDpKqS1KqV+UUtE2S1c2LOnzBOBppVQS+dN1j7NNNMPc6e98iWx6T1FhHUqpp4FI4EGjs5Q1pZQJ+BAYYnAUW3Mlf9glivz/xDYqpRpqrdOMDFXG+gNztdYfKKUeIP+mORFaa7PRwexFeT1Cd8b7mFrSZ5RSDwP/ALprrbNslK0sldRvXyACiFNKHSV/rHG5nZ8YteS9TgKWa61ztNaJwCHyC7y9sqTPw4HvALTWPwOe5E9i5ags+p2/E+W1oDvjfUxL7LNSqikwjfxibu9jqtcU22+t9UWtdaDWOlxrHU7+uYPuWuudxsS1Ckt+vpeRf3SOUiqQ/CGYBBtmtDZL+nwc6ASglKpPfkE/Z9OUtrUcGFxwtUtr4KLW+tRdbdHoM8HFnCHuSv5RyRHgHwXPTST/lxny3+yFwGFgO1DL6Mw26PN64Aywt+BrudGZbdHvm9rGYedXuVj4Xivyh5rigX1AP6Mz26DPDYAt5F8BsxfobHTmu+xvDHAKyCH/P67hwGhgdKH3eGrB92OfNX6u5aP/QgjhIMrrkIsQQog7JAVdCCEchBR0IYRwEFLQhRDCQUhBF0IIByEFXQghHIQUdCGEcBD/H1zUZIYGte5oAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "k0 = 2.14\n", - "def f(t):\n", - " return k0 * torch.cos(k0*t)\n", - "\n", - "def F(t):\n", - " return torch.sin(k0*t)\n", - "\n", - "model.fix_branch_input(f)\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 -} diff --git a/examples/deeponet/oscillator.ipynb b/examples/deeponet/oscillator.ipynb deleted file mode 100644 index cf76ce97..00000000 --- a/examples/deeponet/oscillator.ipynb +++ /dev/null @@ -1,460 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import torchphysics as tp\n", - "import torch\n", - "import pytorch_lightning as pl" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Problem params:\n", - "x0 = [0.0, 0.5] # inital position/speed\n", - "t_end = 10 # sec\n", - "D = 1\n", - "omega_0 = 1\n", - "mu = 0.75\n", - "# Spaces \n", - "T = tp.spaces.R1('t') # input variable\n", - "U = tp.spaces.R1('u') # output variable\n", - "K1 = tp.spaces.R1('k1') # parameter\n", - "K2 = tp.spaces.R1('k2') # parameter\n", - "F = tp.spaces.R1('f') # function output space name\n", - "# Domains\n", - "A_t = tp.domains.Interval(T, 0.0, t_end)\n", - "K_int = tp.domains.Interval(K1, 0, 2)\n", - "K_int2 = tp.domains.Interval(K2, 5, 10)\n", - "#Sampler (for inner sampler add the left boundary, else delta right-hand side can't be learned)\n", - "inner_sampler = tp.samplers.RandomUniformSampler(A_t, n_points = 4000) + tp.samplers.GridSampler(A_t.boundary_left, n_points = 1).make_static()\n", - "initial_u_sampler = tp.samplers.GridSampler(A_t.boundary_left, n_points = 1).make_static()\n", - "initial_v_sampler = tp.samplers.GridSampler(A_t.boundary_left, n_points = 1).make_static()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# Defining function set\n", - "Fn_space = tp.spaces.FunctionSpace(A_t, F)\n", - "\n", - "def f1(k1, t):\n", - " return torch.sin(k1*t)\n", - "\n", - "def delta(k2, t):\n", - " return k2 * torch.isclose(t, torch.tensor(0.0))\n", - "\n", - "param_sampler = tp.samplers.RandomUniformSampler(K_int, n_points=100)\n", - "param_sampler_delta = tp.samplers.RandomUniformSampler(K_int2, n_points=50)\n", - "Fn_set_1 = tp.domains.CustomFunctionSet(Fn_space, param_sampler, f1)\n", - "Fn_set_2 = tp.domains.CustomFunctionSet(Fn_space, param_sampler_delta, delta)\n", - "Fn_set = Fn_set_1 + Fn_set_2" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# custom convolution that should be used for the branch,\n", - "# can also apply some pooling, or something else, if needed.\n", - "# Just the output dimension and input of the linear layers has to fit\n", - "class ConvolutionLayers(torch.nn.Module):\n", - " def __init__(self):\n", - " super().__init__()\n", - " self.conv1 = torch.nn.Conv1d(1, 1, 51, padding=25)\n", - " self.activation = torch.nn.Tanh()\n", - "\n", - " def forward(self, x):\n", - " return self.activation(self.conv1(x))\n", - "\n", - "# custom activation, from old notebook\n", - "class DampedSine(torch.nn.Module):\n", - " def __init__(self):\n", - " super().__init__()\n", - " pass\n", - "\n", - " def forward(self, Tensor):\n", - " alpha = 0.1\n", - " return torch.exp(-alpha * Tensor) * torch.sin(Tensor)\n", - "\n", - "# 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, hidden=(50, 50),\n", - " xavier_gains=[3/5, 3/5, 0.0])\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, U, output_neurons=80)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def u_constrain(u, t):\n", - " return u * t **2 / t_end**2 + x0[1]*t + x0[0]\n", - "\n", - "def ode_residual(u, f, t):\n", - " u_con = u_constrain(u, t)\n", - " u_t = tp.utils.grad(u_con, t)\n", - " lhs = tp.utils.grad(u_t, t) + 2*D*u_t + omega_0**2 * (u_con + mu*u_con**3) \n", - " return lhs - f\n", - "\n", - "ode_cond = tp.conditions.PIDeepONetCondition(deeponet_model=model, \n", - " function_set=Fn_set, \n", - " input_sampler=inner_sampler, \n", - " name='ode_condition',\n", - " residual_fn=ode_residual)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'\\ndef initial_residual(u):\\n return u - x0[0]\\n\\ninitial_cond = tp.conditions.PIDeepONetCondition(deeponet_model=model, \\n function_set=Fn_set, \\n input_sampler=initial_u_sampler, \\n residual_fn=initial_residual, weight=1000)\\n\\ndef initial_speed_residual(u, t):\\n return tp.utils.grad(u, t) - x0[1]\\n\\ninitial_speed_cond = tp.conditions.PIDeepONetCondition(deeponet_model=model, \\n function_set=Fn_set, \\n input_sampler=initial_u_sampler, \\n residual_fn=initial_residual, weight=1000)\\n'" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\"\"\"\n", - "def initial_residual(u):\n", - " return u - x0[0]\n", - "\n", - "initial_cond = tp.conditions.PIDeepONetCondition(deeponet_model=model, \n", - " function_set=Fn_set, \n", - " input_sampler=initial_u_sampler, \n", - " residual_fn=initial_residual, weight=1000)\n", - "\n", - "def initial_speed_residual(u, t):\n", - " return tp.utils.grad(u, t) - x0[1]\n", - "\n", - "initial_speed_cond = tp.conditions.PIDeepONetCondition(deeponet_model=model, \n", - " function_set=Fn_set, \n", - " input_sampler=initial_u_sampler, \n", - " residual_fn=initial_residual, weight=1000)\n", - "\"\"\"" - ] - }, - { - "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: [3]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 933 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "933 K Trainable params\n", - "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 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 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": "59015f1c25d44d81b08ccf672fc9ad54", - "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": "460abca5f9a34718afe42d3137125006", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "solver = tp.solver.Solver([ode_cond])\n", - "\n", - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=30000, \n", - " logger=False, \n", - " enable_checkpointing=False)\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: [3]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 933 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "933 K Trainable params\n", - "0 Non-trainable params\n", - "933 K Total params\n", - "3.735 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "17ef34adef49498bb58127bc9d8151b1", - "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": "d3ed94b3061a4eba88de1a102194739c", - "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": "df5cb8df26d242d98acf98368734a9de", - "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, \n", - " optimizer_args={'max_iter':2, 'history_size': 100})\n", - "\n", - "# here now use grid points:\n", - "ode_cond.input_sampler = tp.samplers.GridSampler(A_t, n_points=4000).make_static()\n", - "# also fix parameters for input functions and take some more:\n", - "Fn_set_1.parameter_sampler.n_points = 120\n", - "Fn_set_1.parameter_sampler = Fn_set_1.parameter_sampler.make_static()\n", - "Fn_set_2.parameter_sampler.n_points = 80\n", - "Fn_set_2.parameter_sampler = Fn_set_2.parameter_sampler.make_static()\n", - "\n", - "solver = tp.solver.Solver(train_conditions=[ode_cond], optimizer_setting=optim)\n", - "\n", - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=2500, \n", - " logger=False, \n", - " enable_checkpointing=False)\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": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "k0 = 1.8\n", - "def f(t):\n", - " a = torch.sin(k0*t)\n", - " return a\n", - "\n", - "\n", - "model.fix_branch_input(f)\n", - "grid_sampler = tp.samplers.GridSampler(A_t, 2000)\n", - "grid_points = grid_sampler.sample_points().unsqueeze(0)\n", - "out = u_constrain(model(grid_points).as_tensor.detach()[0], grid_points.as_tensor.squeeze(0))\n", - "# euler:\n", - "grid_p = grid_points.as_tensor.squeeze(0)\n", - "dis_f = f(grid_p).squeeze(0)\n", - "delta_t = grid_p[1] - grid_p[0]\n", - "u, v = torch.zeros_like(dis_f), torch.zeros_like(dis_f)\n", - "u[0] = x0[0]\n", - "v[0] = x0[1]\n", - "for i in range(len(u)-1):\n", - " v[i+1] = v[i] + delta_t * (dis_f[i] - 2*D*v[i] - omega_0**2*(u[i] + mu * u[i]**3))\n", - " u[i+1] = u[i] + delta_t * v[i]\n", - "plt.plot(grid_p, out)\n", - "plt.plot(grid_p, u)\n", - "plt.grid()\n", - "plt.legend(['Network output', 'Euler 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", - "k0 = 5.0\n", - "def f(t):\n", - " a = k0 * torch.isclose(t, torch.tensor(0.0))\n", - " return a\n", - "\n", - "\n", - "model.fix_branch_input(f)\n", - "grid_sampler = tp.samplers.GridSampler(A_t.boundary_left, 1) + tp.samplers.GridSampler(A_t, 2000)\n", - "grid_points = grid_sampler.sample_points()\n", - "out = u_constrain(model(grid_points).as_tensor.detach()[0], grid_points.as_tensor)\n", - "# euler:\n", - "grid_p = grid_points.as_tensor\n", - "dis_f = f(grid_p).squeeze(0)\n", - "delta_t = grid_p[1] - grid_p[0]\n", - "u, v = torch.zeros_like(dis_f), torch.zeros_like(dis_f)\n", - "u[0] = x0[0]\n", - "v[0] = x0[1]\n", - "for i in range(len(u)-1):\n", - " v[i+1] = v[i] + delta_t * (dis_f[i] - 2*D*v[i] - omega_0**2*(u[i] + mu * u[i]**3))\n", - " u[i+1] = u[i] + delta_t * v[i]\n", - "plt.plot(grid_p, out)\n", - "plt.plot(grid_p, u)\n", - "plt.grid()\n", - "plt.legend(['Network output', 'Euler solution'])" - ] - } - ], - "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.11.7" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/fno/diffusion_2D.ipynb b/examples/fno/diffusion_2D.ipynb deleted file mode 100644 index c4f5abd0..00000000 --- a/examples/fno/diffusion_2D.ipynb +++ /dev/null @@ -1,376 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### FNO: Solving a diffusion equation for different conductivty\n", - "We want to solve the following equation\n", - "\\begin{align*}\n", - " -\\text{div}(\\kappa(x) \\nabla u(x)) &= 10 &&\\text{ in } \\Omega, \\\\\n", - " u &= 0 &&\\text{ on } \\partial \\Omega,\n", - "\\end{align*}\n", - "for functions $\\kappa: \\Omega \\to \\mathbb{R}$. As a domain we consider the unit square $\\Omega = [0, 1]^2$.\n", - "\n", - "The possible $\\kappa$ are created from [perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) and the dataset was created with the finite element method. " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import torch \n", - "import torchphysics as tp\n", - "import pytorch_lightning as pl\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we load the data. The complete dataset consists of 6000 instances of pairs $(\\kappa, u)$. \n", - "5000 will be used in the training process, while the remaining once are later used to test the FNO on unseen data." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "input_data = torch.tensor(np.load(\"datasets/diffusion_input.npy\"), dtype=torch.float32)\n", - "output_data = torch.tensor(np.load(\"datasets/diffusion_output.npy\"), dtype=torch.float32)\n", - "\n", - "train_batch_size = 5000\n", - "train_input = input_data[:train_batch_size]\n", - "train_output = output_data[:train_batch_size]\n", - "\n", - "# Plot one example of the data\n", - "f, axarr = plt.subplots(1,2, figsize=(6, 10))\n", - "plot_idx = 1402\n", - "axarr[0].imshow(train_input[plot_idx])\n", - "axarr[0].title.set_text(r\"Example $\\kappa$\")\n", - "axarr[1].imshow(train_output[plot_idx])\n", - "axarr[1].title.set_text(r\"Example solution $u$\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In TorchPhysics we have to define the input and output space like always:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "K = tp.spaces.R1(\"k\")\n", - "U = tp.spaces.R1(\"u\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next we create the network that learns the mapping:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "hidden_channels = 12\n", - "\n", - "model = tp.models.FNO(K, U, \n", - " fourier_layers=4, \n", - " hidden_channels=hidden_channels, \n", - " fourier_modes=(12, 12), # Here two modes need to be set (one for each space direction) \n", - " skip_connections=True, \n", - " channel_down_sample_network=torch.nn.Sequential(\n", - " torch.nn.Linear(hidden_channels, hidden_channels),\n", - " torch.nn.Tanh(),\n", - " torch.nn.Linear(hidden_channels, U.dim)\n", - " ))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we create a data condition to fit the FNO to the data." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "input_data_points = tp.spaces.Points(train_input, K)\n", - "output_data_points = tp.spaces.Points(train_output, U)\n", - "\n", - "batch_size = train_batch_size // 4\n", - "\n", - "dataloader = tp.utils.PointsDataLoader((input_data_points, output_data_points),\n", - " batch_size=batch_size)\n", - "\n", - "data_condition = tp.conditions.DataCondition(model, dataloader, norm=2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Start training:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True (cuda), 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", - "You are using a CUDA device ('GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3,4,5,6]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 7.7 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "7.7 K Trainable params\n", - "0 Non-trainable params\n", - "7.7 K Total params\n", - "0.031 Total estimated model params size (MB)\n", - "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n", - "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: 100%|██████████| 10000/10000 [16:23<00:00, 10.17it/s, train/loss=0.00143]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "`Trainer.fit` stopped: `max_steps=10000` reached.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: 100%|██████████| 10000/10000 [16:23<00:00, 10.17it/s, train/loss=0.00143]\n" - ] - } - ], - "source": [ - "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.005)\n", - "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", - "\n", - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=10000, \n", - " logger=False, \n", - " enable_checkpointing=False)\n", - "\n", - "trainer.fit(solver)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True (cuda), 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: [0,1,2,3,4,5,6]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 7.7 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "7.7 K Trainable params\n", - "0 Non-trainable params\n", - "7.7 K Total params\n", - "0.031 Total estimated model params size (MB)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: 100%|██████████| 10000/10000 [32:14<00:00, 5.17it/s, train/loss=0.00101]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "`Trainer.fit` stopped: `max_steps=10000` reached.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: 100%|██████████| 10000/10000 [32:14<00:00, 5.17it/s, train/loss=0.00101]\n" - ] - } - ], - "source": [ - "batch_size = train_batch_size // 2\n", - "\n", - "dataloader = tp.utils.PointsDataLoader((input_data_points, output_data_points),\n", - " batch_size=batch_size)\n", - "\n", - "data_condition = tp.conditions.DataCondition(model, dataloader, norm=2)\n", - "\n", - "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.001)\n", - "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", - "\n", - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=10000, \n", - " logger=False, \n", - " enable_checkpointing=False)\n", - "\n", - "trainer.fit(solver)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "One could train further and try to optimize the network architecture as well as the training procedure some more. But for this example we are fine with this result. We obtain:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Relative error: 16.17975616455078 %\n" - ] - } - ], - "source": [ - "test_input = input_data[train_batch_size:]\n", - "test_output = output_data[train_batch_size:]\n", - "model_output = model(tp.spaces.Points(test_input, K)).as_tensor\n", - "\n", - "rel_error = torch.max(torch.abs(model_output - test_output)) / torch.max(test_output)\n", - "\n", - "print(f\"Relative error: {rel_error*100} %\")" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot one example of data\n", - "plot_idx = 103 # <- value between 0 and 999\n", - "\n", - "f, axarr = plt.subplots(1,4, figsize=(20, 6))\n", - "img = axarr[0].imshow(test_input[plot_idx])\n", - "axarr[0].title.set_text(r\"Test $\\kappa$\")\n", - "plt.colorbar(img, ax=axarr[0], shrink=0.75)\n", - "\n", - "sol_min = torch.min(test_output[plot_idx])\n", - "sol_max = torch.max(test_output[plot_idx])\n", - "img = axarr[1].imshow(test_output[plot_idx], vmin=sol_min, vmax=sol_max)\n", - "axarr[1].title.set_text(r\"Expected $u$\")\n", - "plt.colorbar(img, ax=axarr[1], shrink=0.75)\n", - "\n", - "img = axarr[2].imshow(model_output[plot_idx].detach(), vmin=sol_min, vmax=sol_max)\n", - "axarr[2].title.set_text(r\"FNO $u$\")\n", - "plt.colorbar(img, ax=axarr[2], shrink=0.75)\n", - "\n", - "error = torch.abs(model_output[plot_idx].detach() - test_output[plot_idx])\n", - "img = axarr[3].imshow(error, cmap='jet')\n", - "axarr[3].title.set_text(r\"Difference\")\n", - "plt.colorbar(img, ax=axarr[3], shrink=0.75)\n", - "\n", - "plt.tight_layout()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "tp_version2", - "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.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/fno/integrator(+batchnorm).ipynb b/examples/fno/integrator(+batchnorm).ipynb deleted file mode 100644 index 4e43b64e..00000000 --- a/examples/fno/integrator(+batchnorm).ipynb +++ /dev/null @@ -1,380 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Fourier Neural Operator (FNO): Solving a ODE for different right hand sides\n", - "In this notebook, we present the same problem as in [this notebook](https://arxiv.org/abs/2010.08895), but also add a batch normalization in space which leads to smoother learned solutions. \n", - "As an example, we try to learn the integral operator of 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$. " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import torch \n", - "import torchphysics as tp\n", - "import pytorch_lightning as pl" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First create the data set we need for training the network.\n", - "Here we randomly create some oscillating functions and use an explicit euler to compute our training data." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "N_batch = 5000 # Data in trainig set\n", - "N_time = 100 # resolution of time (or space) interval\n", - "dt = 1/N_time\n", - "\n", - "input_data = torch.zeros((N_batch, N_time, 1))\n", - "random_data = torch.zeros((N_batch, 3))\n", - "random_data[:, :1] = torch.randint(0, 24, (N_batch, 1))\n", - "random_data[:, 1:2] = torch.randint(0, 12, (N_batch, 1))\n", - "random_data[:, 2:] = torch.randint(0, 6, (N_batch, 1))\n", - "\n", - "output_data = torch.zeros((N_batch, N_time, 1))\n", - "\n", - "t = 0.0\n", - "input_data[:, 0, 0] = torch.sin(t * random_data[:, 0]) + 0.5 * torch.cos(t * random_data[:, 1]) \\\n", - " + 2.0 * torch.sin(t * random_data[:, 2])\n", - "for i in range(1, N_time):\n", - " t += dt\n", - " input_data[:, i, 0] = torch.sin(t * random_data[:, 0]) + 0.5 * torch.cos(t * random_data[:, 1]) \\\n", - " + 2.0 * torch.sin(t * random_data[:, 2])\n", - " output_data[:, i, 0] = output_data[:, i-1, 0] + dt * input_data[:, i, 0]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In TorchPhysics we have to define the input and output space like always:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "F = tp.spaces.R1(\"f\")\n", - "U = tp.spaces.R1(\"u\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next we create the network that learns the mapping:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "hidden_channels = 8\n", - "\n", - "model = tp.models.FNO(F, U, \n", - " fourier_layers=3, \n", - " hidden_channels=hidden_channels, \n", - " fourier_modes=8, \n", - " skip_connections=True, \n", - " channel_down_sample_network=torch.nn.Sequential(\n", - " torch.nn.Linear(hidden_channels, hidden_channels),\n", - " torch.nn.Tanh(),\n", - " torch.nn.Linear(hidden_channels, U.dim)\n", - " ),\n", - " space_resolution=100) # by setting the resolution of the space, we enable batch norm computations.\n", - "# Note: This (currently) disables the super resolution property of the FNO, so the input always needs to be\n", - "# on the same grid " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we create a data condition to fit the FNO to the data." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# Transform data to points\n", - "input_data_points = tp.spaces.Points(input_data, F)\n", - "output_data_points = tp.spaces.Points(output_data, U)\n", - "\n", - "dataloader = tp.utils.PointsDataLoader((input_data_points, output_data_points),\n", - " batch_size=N_batch)\n", - "\n", - "data_condition = tp.conditions.DataCondition(model, dataloader, norm=2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Start training:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True (cuda), 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", - "You are using a CUDA device ('GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3,4,5,6]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 1.1 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "1.1 K Trainable params\n", - "0 Non-trainable params\n", - "1.1 K Total params\n", - "0.004 Total estimated model params size (MB)\n", - "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n", - "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: 100%|██████████| 5000/5000 [00:53<00:00, 94.12it/s, train/loss=1.28e-5] " - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "`Trainer.fit` stopped: `max_steps=5000` reached.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: 100%|██████████| 5000/5000 [00:53<00:00, 94.11it/s, train/loss=1.28e-5]\n" - ] - } - ], - "source": [ - "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.01)\n", - "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", - "\n", - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=5000, \n", - " logger=False, \n", - " enable_checkpointing=False)\n", - "\n", - "trainer.fit(solver)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Decrease learning rate and fine tune some more:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True (cuda), 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: [0,1,2,3,4,5,6]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 1.1 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "1.1 K Trainable params\n", - "0 Non-trainable params\n", - "1.1 K Total params\n", - "0.004 Total estimated model params size (MB)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: 0%| | 0/8000 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "example_plot = 78\n", - "t = torch.linspace(0, 1, N_time)\n", - "plt.plot(t, model_output[example_plot, :, 0].detach().cpu())\n", - "plt.plot(t, output_data_test[example_plot, :, 0].detach().cpu())\n", - "plt.legend([\"FNO Solution\", \"Correct Solution\"])\n", - "plt.grid()" - ] - } - ], - "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.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/fno/integrator.ipynb b/examples/fno/integrator.ipynb deleted file mode 100644 index f83e7bb2..00000000 --- a/examples/fno/integrator.ipynb +++ /dev/null @@ -1,376 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Fourier Neural Operator (FNO): Solving a ODE for different right hand sides\n", - "In this notebook, we present an introduction to the FNO [(paper)](https://arxiv.org/abs/2010.08895) utilities of TorchPhysics. \n", - "As an example, we try to learn the integral operator of 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$. " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import torch \n", - "import torchphysics as tp\n", - "import pytorch_lightning as pl" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First create the data set we need for training the network.\n", - "Here we randomly create some oscillating functions and use an explicit euler to compute our training data." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "N_batch = 5000 # Data in trainig set\n", - "N_time = 100 # resolution of time (or space) interval\n", - "dt = 1/N_time\n", - "\n", - "input_data = torch.zeros((N_batch, N_time, 1))\n", - "random_data = torch.zeros((N_batch, 3))\n", - "random_data[:, :1] = torch.randint(0, 24, (N_batch, 1))\n", - "random_data[:, 1:2] = torch.randint(0, 12, (N_batch, 1))\n", - "random_data[:, 2:] = torch.randint(0, 6, (N_batch, 1))\n", - "\n", - "output_data = torch.zeros((N_batch, N_time, 1))\n", - "\n", - "t = 0.0\n", - "input_data[:, 0, 0] = torch.sin(t * random_data[:, 0]) + 0.5 * torch.cos(t * random_data[:, 1]) \\\n", - " + 2.0 * torch.sin(t * random_data[:, 2])\n", - "for i in range(1, N_time):\n", - " t += dt\n", - " input_data[:, i, 0] = torch.sin(t * random_data[:, 0]) + 0.5 * torch.cos(t * random_data[:, 1]) \\\n", - " + 2.0 * torch.sin(t * random_data[:, 2])\n", - " output_data[:, i, 0] = output_data[:, i-1, 0] + dt * input_data[:, i, 0]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In TorchPhysics we have to define the input and output space like always:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "F = tp.spaces.R1(\"f\")\n", - "U = tp.spaces.R1(\"u\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next we create the network that learns the mapping:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "hidden_channels = 8\n", - "\n", - "model = tp.models.FNO(F, U, \n", - " fourier_layers=3, \n", - " hidden_channels=hidden_channels, \n", - " fourier_modes=8, \n", - " skip_connections=True, \n", - " channel_down_sample_network=torch.nn.Sequential(\n", - " torch.nn.Linear(hidden_channels, hidden_channels),\n", - " torch.nn.Tanh(),\n", - " torch.nn.Linear(hidden_channels, U.dim)\n", - " ))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we create a data condition to fit the FNO to the data." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# Transform data to points\n", - "input_data_points = tp.spaces.Points(input_data, F)\n", - "output_data_points = tp.spaces.Points(output_data, U)\n", - "\n", - "dataloader = tp.utils.PointsDataLoader((input_data_points, output_data_points),\n", - " batch_size=N_batch)\n", - "\n", - "data_condition = tp.conditions.DataCondition(model, dataloader, norm=2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Start training:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True (cuda), 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", - "You are using a CUDA device ('GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3,4,5,6]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 505 \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "505 Trainable params\n", - "0 Non-trainable params\n", - "505 Total params\n", - "0.002 Total estimated model params size (MB)\n", - "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n", - "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: 100%|██████████| 5000/5000 [00:47<00:00, 104.95it/s, train/loss=0.00127] " - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "`Trainer.fit` stopped: `max_steps=5000` reached.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: 100%|██████████| 5000/5000 [00:47<00:00, 104.95it/s, train/loss=0.00127]\n" - ] - } - ], - "source": [ - "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.01)\n", - "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", - "\n", - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=5000, \n", - " logger=False, \n", - " enable_checkpointing=False)\n", - "\n", - "trainer.fit(solver)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Decrease learning rate and fine tune some more:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True (cuda), 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: [0,1,2,3,4,5,6]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 505 \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "505 Trainable params\n", - "0 Non-trainable params\n", - "505 Total params\n", - "0.002 Total estimated model params size (MB)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: 100%|██████████| 10000/10000 [01:31<00:00, 108.78it/s, train/loss=0.000454]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "`Trainer.fit` stopped: `max_steps=10000` reached.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: 100%|██████████| 10000/10000 [01:31<00:00, 108.78it/s, train/loss=0.000454]\n" - ] - } - ], - "source": [ - "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.001)\n", - "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", - "\n", - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=10000, \n", - " logger=False, \n", - " enable_checkpointing=False)\n", - "\n", - "trainer.fit(solver)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next we test the network on unseen data. Therefore we create inputs as before and evaluate the model:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Relative error: 11.572426795959473 %\n" - ] - } - ], - "source": [ - "N_test = 100\n", - "N_time = 100\n", - "dt = 1/N_time\n", - "\n", - "test_data = torch.zeros((N_test, N_time, 1))\n", - "output_data_test = torch.zeros((N_test, N_time, 1))\n", - "\n", - "random_data = torch.zeros((N_test, 3))\n", - "random_data[:, :1] = torch.randint(0, 24, (N_test, 1))\n", - "random_data[:, 1:2] = torch.randint(0, 12, (N_test, 1))\n", - "random_data[:, 2:] = torch.randint(0, 6, (N_test, 1))\n", - "\n", - "t = 0.0\n", - "test_data[:, 0, 0] = torch.sin(t * random_data[:, 0]) + 0.5 * torch.cos(t * random_data[:, 1]) \\\n", - " + 2.0 * torch.sin(t * random_data[:, 2])\n", - "for i in range(1, N_time):\n", - " t += dt\n", - " test_data[:, i, 0] = torch.sin(t * random_data[:, 0]) + 0.5 * torch.cos(t * random_data[:, 1]) \\\n", - " + 2.0 * torch.sin(t * random_data[:, 2])\n", - " output_data_test[:, i, 0] = output_data_test[:, i-1, 0] + dt * test_data[:, i, 0]\n", - "\n", - "model_output = model(tp.spaces.Points(test_data, F)).as_tensor\n", - "\n", - "rel_error = torch.max(torch.abs(model_output - output_data_test)) / torch.max(output_data_test)\n", - "\n", - "print(f\"Relative error: {rel_error*100} %\")" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "example_plot = 6\n", - "t = torch.linspace(0, 1, N_time)\n", - "plt.plot(t, model_output[example_plot, :, 0].detach().cpu())\n", - "plt.plot(t, output_data_test[example_plot, :, 0].detach().cpu())\n", - "plt.legend([\"FNO Solution\", \"Correct Solution\"])\n", - "plt.grid()" - ] - } - ], - "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.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/operator_learning/Stokes_2D.ipynb b/examples/operator_learning/Stokes_2D.ipynb new file mode 100644 index 00000000..4233f52e --- /dev/null +++ b/examples/operator_learning/Stokes_2D.ipynb @@ -0,0 +1,472 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Solving a Stokes equation on domains with different obstacles\n", + "We are give a domain $\\Omega_\\chi \\subset \\R^2$ which is defined as all points $x \\in (0, 1)^2$ such that $\\chi(x) = 1$. We will mainly consider random placed circles cut out from the domain $(0, 1)^2$. Our goal is to solve the following Stokes\n", + "equation on $\\Omega_\\chi$:\n", + "\\begin{align*}\n", + " -\\mu \\Delta u - \\nabla p &= 0 &&\\text{ in } \\Omega_\\chi, \\\\\n", + " \\nabla \\cdot u &= 0 &&\\text{ in } \\Omega_\\chi.\n", + "\\end{align*}\n", + "With the boundary conditions:\n", + "\\begin{align*}\n", + " u &= u_{in} &&\\text{ when } x_1 = 0, \\\\\n", + " (\\mu \\nabla u + p) \\cdot n &= 0 &&\\text{ when } x_1 = 1, \\\\\n", + " u &= 0 &&\\text{ everywhere else on } \\partial \\Omega_\\chi.\n", + "\\end{align*}\n", + "Here, $u_{in}$ is a given inflow profile.\n", + "\n", + "Our goal is to learn the solution operator that maps the domain $\\Omega_\\chi$ to the solution $u$.\n", + "\n", + "This example shows the workflow in TorchPhysics for such a 2D problem. We will not get highly accurate results because we are working with a small dataset. This is done to keep the size of the GitHub repository small.\n", + "Better results can be obtained with more data.\n", + "\n", + "The general procedure is the same as for the diffusion equation, so not many comments will be given." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "sys.path.append(os.getcwd())\n", + "\n", + "import torch \n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "input_data = torch.tensor(np.load(\"datasets/stokes_input.npy\"), dtype=torch.float32)\n", + "output_data = torch.tensor(np.load(\"datasets/stokes_output.npy\"), dtype=torch.float32)\n", + "\n", + "loc_data = torch.zeros_like(output_data)\n", + "for i in range(loc_data.shape[1]):\n", + " for j in range(loc_data.shape[2]):\n", + " loc_data[:, j, i, 0] = i / loc_data.shape[1]\n", + " loc_data[:, j, i, 1] = j / loc_data.shape[2]\n", + "\n", + "input_data = torch.concatenate((input_data, loc_data), dim=-1)\n", + "\n", + "train_batch_size = 3500\n", + "train_input = input_data[:train_batch_size]\n", + "train_output = output_data[:train_batch_size]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot one example of the data\n", + "f, axarr = plt.subplots(1,2, figsize=(6, 10))\n", + "plot_idx = 12\n", + "axarr[0].imshow(train_input[plot_idx, :, :, 0], origin='lower')\n", + "axarr[0].title.set_text(r\"Example domain\")\n", + "axarr[1].imshow(train_output[plot_idx, :, :, 0], origin='lower')\n", + "axarr[1].title.set_text(r\"Example solution $u_x$\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In TorchPhysics we have to define the input and output space like always:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "X = tp.spaces.R2(\"x\")\n", + "Phi = tp.spaces.R3(\"phi\")\n", + "U = tp.spaces.R2(\"u\")\n", + "\n", + "fn_space_input = tp.spaces.FunctionSpace(X, Phi)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "data_functionset_input = tp.domains.DataFunctionSet(fn_space_input,\n", + " input_data)\n", + "data_functionset_output = tp.domains.DataFunctionSet(tp.spaces.FunctionSpace(X, U),\n", + " output_data)\n", + "\n", + "functionsampler_input = tp.samplers.FunctionSamplerOrdered(1500, data_functionset_input)\n", + "# The output should be coupled to the correct input functions:\n", + "functionsampler_output = tp.samplers.FunctionSamplerCoupled(data_functionset_output, functionsampler_input)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we create the network that learns the mapping:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "### DeepONet\n", + "# x_grid = torch.linspace(0, 1, 32)\n", + "# point_grid = torch.permute(torch.stack(torch.meshgrid((x_grid, x_grid))), (2, 1, 0)).unsqueeze(0)\n", + "# trunk_net = tp.models.FCTrunkNet(X, hidden=(10, 10), default_trunk_input=point_grid)\n", + "\n", + "# conv_network = torch.nn.Sequential(\n", + "# torch.nn.Conv2d(Phi.dim, 16, kernel_size=3, stride=2, padding=1),\n", + "# torch.nn.Tanh(),\n", + "# torch.nn.Conv2d(16, 1, kernel_size=3, stride=1, padding=1),\n", + "# torch.nn.Tanh()\n", + "# )\n", + "\n", + "# branch_net = tp.models.ConvBranchNet(fn_space_input, \n", + "# convolutional_network=conv_network,\n", + "# hidden=(20, 20), grid=point_grid)\n", + "\n", + "\n", + "# model = tp.models.DeepONet(trunk_net, branch_net, U, output_neurons=50)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "### FNO\n", + "# hidden_channels = 32\n", + "\n", + "# model = tp.models.FNO(Phi, U, \n", + "# fourier_layers=8, \n", + "# hidden_channels=hidden_channels, \n", + "# fourier_modes=(12, 12), # Here two modes need to be set (one for each space direction) \n", + "# skip_connections=True, \n", + "# channel_down_sample_network=torch.nn.Sequential(\n", + "# torch.nn.Linear(hidden_channels, hidden_channels),\n", + "# torch.nn.Tanh(),\n", + "# torch.nn.Linear(hidden_channels, hidden_channels),\n", + "# torch.nn.Tanh(),\n", + "# torch.nn.Linear(hidden_channels, U.dim)\n", + "# ), \n", + "# space_resolution=(32, 32)\n", + "# )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "data_functionset_input.compute_pca(components=50)\n", + "data_functionset_output.compute_pca(components=50)\n", + "\n", + "model = tp.models.PCANN_FC.from_fn_set(\n", + " data_functionset_input, data_functionset_output, hidden=(60, 100, 200, 100, 60)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "data_condition = tp.conditions.OperatorCondition(module=model, \n", + " input_function_sampler=functionsampler_input, \n", + " output_function_sampler=functionsampler_output)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Start training:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), 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", + "You are using a CUDA device ('GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3,4,5,6,7]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 58.6 K\n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "58.6 K Trainable params\n", + "0 Non-trainable params\n", + "58.6 K Total params\n", + "0.234 Total estimated model params size (MB)\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 2000/2000 [00:12<00:00, 166.54it/s, train/loss=0.410]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_steps=2000` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 2000/2000 [00:12<00:00, 166.51it/s, train/loss=0.410]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), 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: [0,1,2,3,4,5,6,7]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 58.6 K\n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "58.6 K Trainable params\n", + "0 Non-trainable params\n", + "58.6 K Total params\n", + "0.234 Total estimated model params size (MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 20000/20000 [01:45<00:00, 190.30it/s, train/loss=0.238]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_steps=20000` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 20000/20000 [01:45<00:00, 190.29it/s, train/loss=0.238]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), 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: [0,1,2,3,4,5,6,7]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 58.6 K\n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "58.6 K Trainable params\n", + "0 Non-trainable params\n", + "58.6 K Total params\n", + "0.234 Total estimated model params size (MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 20000/20000 [01:51<00:00, 179.66it/s, train/loss=0.228]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_steps=20000` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 20000/20000 [01:51<00:00, 179.65it/s, train/loss=0.228]\n" + ] + } + ], + "source": [ + "lr_list = [0.005, 0.001, 0.0001]\n", + "step_list = [2000, 20000, 20000]\n", + "\n", + "for i in range(len(lr_list)):\n", + " optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=lr_list[i])\n", + " solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", + "\n", + " trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=step_list[i], \n", + " logger=False, \n", + " enable_checkpointing=False)\n", + "\n", + " trainer.fit(solver)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One would need more data to get better results, but for this example we now evaluate and obtain:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Relative error: 99.8123550415039 %\n" + ] + } + ], + "source": [ + "test_input = input_data[train_batch_size:]\n", + "test_output = output_data[train_batch_size:]\n", + "\n", + "if isinstance(model, tp.models.DeepONet):\n", + " model_output = model(branch_inputs=tp.spaces.Points(test_input, Phi)).as_tensor\n", + "else:\n", + " model_output = model(tp.spaces.Points(test_input, Phi)).as_tensor\n", + "\n", + "rel_error = torch.max(torch.abs(model_output - test_output)) / torch.max(test_output)\n", + "\n", + "print(f\"Relative error: {rel_error*100} %\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot one example of data\n", + "plot_idx = 2 # <- value between 0 and 499\n", + "\n", + "f, axarr = plt.subplots(1,4, figsize=(20, 6))\n", + "img = axarr[0].imshow(test_input[plot_idx, :, :, 0], origin='lower')\n", + "axarr[0].title.set_text(r\"Test domain\")\n", + "plt.colorbar(img, ax=axarr[0], shrink=0.75)\n", + "\n", + "sol_min = torch.min(test_output[plot_idx])\n", + "sol_max = torch.max(test_output[plot_idx])\n", + "img = axarr[1].imshow(torch.linalg.norm(test_output[plot_idx], dim=-1), vmin=sol_min, vmax=sol_max, origin='lower')\n", + "axarr[1].title.set_text(r\"Expected mag. of $u$\")\n", + "plt.colorbar(img, ax=axarr[1], shrink=0.75)\n", + "\n", + "img = axarr[2].imshow(torch.linalg.norm(model_output[plot_idx].detach(), dim=-1), vmin=sol_min, vmax=sol_max, origin='lower')\n", + "axarr[2].title.set_text(r\"Predicted mag. of $u$\")\n", + "plt.colorbar(img, ax=axarr[2], shrink=0.75)\n", + "\n", + "error = torch.linalg.norm(model_output[plot_idx].detach() - test_output[plot_idx], dim=-1)\n", + "img = axarr[3].imshow(error, cmap='jet', origin='lower')\n", + "axarr[3].title.set_text(r\"Difference\")\n", + "plt.colorbar(img, ax=axarr[3], shrink=0.75)\n", + "\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tp_version2", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/operator_learning/datasets/diffusion_input_small.npy b/examples/operator_learning/datasets/diffusion_input_small.npy new file mode 100644 index 00000000..6e78aeda Binary files /dev/null and b/examples/operator_learning/datasets/diffusion_input_small.npy differ diff --git a/examples/operator_learning/datasets/diffusion_output_small.npy b/examples/operator_learning/datasets/diffusion_output_small.npy new file mode 100644 index 00000000..89d8c9eb Binary files /dev/null and b/examples/operator_learning/datasets/diffusion_output_small.npy differ diff --git a/examples/operator_learning/datasets/generate_ode_data.py b/examples/operator_learning/datasets/generate_ode_data.py new file mode 100644 index 00000000..fd2404e9 --- /dev/null +++ b/examples/operator_learning/datasets/generate_ode_data.py @@ -0,0 +1,23 @@ +import torch + +def generate_ode_data(N_batch, N_time, dt): + # Sample random data to build different rhs f: + input_data = torch.zeros((N_batch, N_time, 1)) + random_data = torch.zeros((N_batch, 3)) + random_data[:, :1] = torch.randint(0, 24, (N_batch, 1)) + random_data[:, 1:2] = torch.randint(0, 12, (N_batch, 1)) + random_data[:, 2:] = torch.randint(0, 6, (N_batch, 1)) + + output_data = torch.zeros((N_batch, N_time, 1)) + + t = 0.0 + input_data[:, 0, 0] = torch.sin(t * random_data[:, 0]) + 0.5 * torch.cos(t * random_data[:, 1]) \ + + 2.0 * torch.sin(t * random_data[:, 2]) + # Do Euler scheme to compute reference solution + for i in range(1, N_time): + t += dt + input_data[:, i, 0] = torch.sin(t * random_data[:, 0]) + 0.5 * torch.cos(t * random_data[:, 1]) \ + + 2.0 * torch.sin(t * random_data[:, 2]) + output_data[:, i, 0] = output_data[:, i-1, 0] + dt * input_data[:, i, 0] + + return input_data, output_data \ No newline at end of file diff --git a/examples/operator_learning/datasets/stokes_input.npy b/examples/operator_learning/datasets/stokes_input.npy new file mode 100644 index 00000000..39b7c289 Binary files /dev/null and b/examples/operator_learning/datasets/stokes_input.npy differ diff --git a/examples/operator_learning/datasets/stokes_output.npy b/examples/operator_learning/datasets/stokes_output.npy new file mode 100644 index 00000000..d677cf4a Binary files /dev/null and b/examples/operator_learning/datasets/stokes_output.npy differ diff --git a/examples/operator_learning/diffusion_2D.ipynb b/examples/operator_learning/diffusion_2D.ipynb new file mode 100644 index 00000000..abf10ea9 --- /dev/null +++ b/examples/operator_learning/diffusion_2D.ipynb @@ -0,0 +1,453 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Solving a diffusion equation for different conductivty fields\n", + "We want to solve the following equation\n", + "\\begin{align*}\n", + " -\\text{div}(\\kappa(x) \\nabla u(x)) &= 10 &&\\text{ in } \\Omega, \\\\\n", + " u &= 0 &&\\text{ on } \\partial \\Omega,\n", + "\\end{align*}\n", + "for functions $\\kappa: \\Omega \\to \\mathbb{R}$. As a domain we consider the unit square $\\Omega = [0, 1]^2$.\n", + "\n", + "The possible $\\kappa$ are generated from [perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) and the dataset was generated using the finite element method. \n", + "\n", + "This example shows the workflow in TorchPhysics for such a 2D problem. We will not get highly accurate results because we are working with a small dataset of 600 instances of pairs $(\\kappa, u)$. This is done to keep the size of the GitHub repository small.\n", + "Better results can be obtained with more data." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "sys.path.append(os.getcwd())\n", + "\n", + "import torch \n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we load the data. \n", + "The complete dataset consists of 600 instances of pairs $(\\kappa, u)$. \n", + "500 will be used in the training process, while the remaining once are later used to test the FNO on unseen data.\n", + "\n", + "As mentioned before, this is quite a small data set and we can not expect to obtain a good generalization of the model. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "input_data = torch.tensor(np.load(\"datasets/diffusion_input_small.npy\"), dtype=torch.float32)\n", + "output_data = torch.tensor(np.load(\"datasets/diffusion_output_small.npy\"), dtype=torch.float32)\n", + "\n", + "train_batch_size = 500\n", + "train_input = input_data[:train_batch_size]\n", + "train_output = output_data[:train_batch_size]\n", + "\n", + "# Plot one example of the data\n", + "f, axarr = plt.subplots(1,2, figsize=(6, 10))\n", + "plot_idx = 142\n", + "axarr[0].imshow(train_input[plot_idx])\n", + "axarr[0].title.set_text(r\"Example $\\kappa$\")\n", + "axarr[1].imshow(train_output[plot_idx])\n", + "axarr[1].title.set_text(r\"Example solution $u$\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In TorchPhysics we have to define the input and output space like always:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "X = tp.spaces.R2(\"x\")\n", + "K = tp.spaces.R1(\"k\")\n", + "U = tp.spaces.R1(\"u\")\n", + "\n", + "function_space_input = tp.spaces.FunctionSpace(X, K)\n", + "function_space_output = tp.spaces.FunctionSpace(X, U)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Put the data into the FunctionSet format\n", + "data_functionset_input = tp.domains.DataFunctionSet(function_space_input, input_data)\n", + "data_functionset_output = tp.domains.DataFunctionSet(function_space_output, output_data)\n", + "\n", + "functionsampler_input = tp.samplers.FunctionSamplerOrdered(250, data_functionset_input)\n", + "# The output should be coupled to the correct input functions:\n", + "functionsampler_output = tp.samplers.FunctionSamplerCoupled(data_functionset_output, functionsampler_input)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we create the network that learns the mapping. Again we can easily switch between different approaches:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/torch/functional.py:507: 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:3549.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/torch/nn/modules/lazy.py:181: UserWarning: Lazy modules are a new feature under heavy development so changes to the API or functionality can happen at any moment.\n", + " warnings.warn('Lazy modules are a new feature under heavy development '\n" + ] + } + ], + "source": [ + "### DeepONet\n", + "x_grid = torch.linspace(0, 1, 64)\n", + "point_grid = torch.permute(torch.stack(torch.meshgrid((x_grid, x_grid))), (2, 1, 0)).unsqueeze(0)\n", + "trunk_net = tp.models.FCTrunkNet(X, hidden=(10, 10), default_trunk_input=point_grid)\n", + "\n", + "conv_network = torch.nn.Sequential(\n", + " torch.nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1),\n", + " torch.nn.Tanh(),\n", + " torch.nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=1),\n", + " torch.nn.Tanh(),\n", + " torch.nn.Conv2d(16, 1, kernel_size=3, stride=1, padding=1),\n", + " torch.nn.Tanh()\n", + ")\n", + "\n", + "branch_net = tp.models.ConvBranchNet(function_space_input, \n", + " convolutional_network=conv_network,\n", + " hidden=(20, 20), grid=point_grid)\n", + "\n", + "\n", + "model = tp.models.DeepONet(trunk_net, branch_net, U, output_neurons=50)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "### FNO:\n", + "# hidden_channels = 12\n", + "\n", + "# model = tp.models.FNO(K, U, \n", + "# fourier_layers=4, \n", + "# hidden_channels=hidden_channels, \n", + "# fourier_modes=(12, 12), # Here two modes need to be set (one for each space direction) \n", + "# skip_connections=True, \n", + "# channel_down_sample_network=torch.nn.Sequential(\n", + "# torch.nn.Linear(hidden_channels, hidden_channels),\n", + "# torch.nn.Tanh(),\n", + "# torch.nn.Linear(hidden_channels, U.dim)\n", + "# ))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "### Model order reduction network:\n", + "# data_functionset_input.compute_pca(components=50)\n", + "# data_functionset_output.compute_pca(components=50)\n", + "\n", + "# model = tp.models.PCANN_FC.from_fn_set(\n", + "# data_functionset_input, data_functionset_output, hidden=(60, 80, 100, 80, 60)\n", + "# )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we create a data condition to fit the model to the data:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "data_condition = tp.conditions.OperatorCondition(module=model, \n", + " input_function_sampler=functionsampler_input, \n", + " output_function_sampler=functionsampler_output)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Start training:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), 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", + "You are using a CUDA device ('GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3,4,5,6,7]\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/utilities/model_summary/model_summary.py:452: A layer with UninitializedParameter was found. Thus, the total number of parameters detected may be inaccurate.\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 4.8 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "4.8 K Trainable params\n", + "0 Non-trainable params\n", + "4.8 K Total params\n", + "0.019 Total estimated model params size (MB)\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 10000/10000 [01:09<00:00, 144.05it/s, train/loss=0.501]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_steps=10000` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 10000/10000 [01:09<00:00, 144.04it/s, train/loss=0.501]\n" + ] + } + ], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.005)\n", + "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=10000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", + "\n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), 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: [0,1,2,3,4,5,6,7]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 9.9 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "9.9 K Trainable params\n", + "0 Non-trainable params\n", + "9.9 K Total params\n", + "0.040 Total estimated model params size (MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 5000/5000 [00:33<00:00, 147.15it/s, train/loss=0.405]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_steps=5000` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 5000/5000 [00:33<00:00, 147.14it/s, train/loss=0.405]\n" + ] + } + ], + "source": [ + "functionsampler_input.n_functions = 500\n", + "\n", + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.001)\n", + "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", + "\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=5000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", + "\n", + "trainer.fit(solver)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the results on unseen data (as explained before the results will be not great but should roughly predict the solution)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Relative error: 44.55781936645508 %\n" + ] + } + ], + "source": [ + "test_input = input_data[train_batch_size:]\n", + "test_output = output_data[train_batch_size:]\n", + "\n", + "if isinstance(model, tp.models.DeepONet):\n", + " model_output = model(branch_inputs=tp.spaces.Points(test_input, K)).as_tensor\n", + "else:\n", + " model_output = model(tp.spaces.Points(test_input, K)).as_tensor\n", + "\n", + "rel_error = torch.max(torch.abs(model_output - test_output)) / torch.max(test_output)\n", + "\n", + "print(f\"Relative error: {rel_error*100} %\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot one example of data\n", + "plot_idx = 1 # <- value between 0 and 99\n", + "\n", + "f, axarr = plt.subplots(1,4, figsize=(20, 6))\n", + "img = axarr[0].imshow(test_input[plot_idx])\n", + "axarr[0].title.set_text(r\"Test $\\kappa$\")\n", + "plt.colorbar(img, ax=axarr[0], shrink=0.75)\n", + "\n", + "sol_min = torch.min(test_output[plot_idx])\n", + "sol_max = torch.max(test_output[plot_idx])\n", + "img = axarr[1].imshow(test_output[plot_idx], vmin=sol_min, vmax=sol_max)\n", + "axarr[1].title.set_text(r\"Expected $u$\")\n", + "plt.colorbar(img, ax=axarr[1], shrink=0.75)\n", + "\n", + "img = axarr[2].imshow(model_output[plot_idx].detach(), vmin=sol_min, vmax=sol_max)\n", + "axarr[2].title.set_text(r\"Predicted $u$\")\n", + "plt.colorbar(img, ax=axarr[2], shrink=0.75)\n", + "\n", + "error = torch.abs(model_output[plot_idx].detach() - test_output[plot_idx])\n", + "img = axarr[3].imshow(error, cmap='jet')\n", + "axarr[3].title.set_text(r\"Difference\")\n", + "plt.colorbar(img, ax=axarr[3], shrink=0.75)\n", + "\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tp_version2", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/operator_learning/introductory_example.ipynb b/examples/operator_learning/introductory_example.ipynb new file mode 100644 index 00000000..25053f1a --- /dev/null +++ b/examples/operator_learning/introductory_example.ipynb @@ -0,0 +1,493 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Operator Learning: Solving a ODE for different right hand sides\n", + "\n", + "In this notebook, we present an introduction to the operator learning utilities of TorchPhysics. \n", + "As an example, we start easy and try to learn the integral operator of 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$. \n", + "\n", + "We will cover different operator learning approaches as they are all unifited in TorchPhysics and can be easily swapped out. The following methods will be used in this introduction:\n", + "\n", + "- Deep Operator Networks (DeepONet) [(paper)](https://arxiv.org/abs/2103.10974)\n", + "- Fourier Neural Operators (FNO) [(paper)](https://arxiv.org/abs/2010.08895)\n", + "- Model order reduction networks (PCANN) [(paper)](https://arxiv.org/abs/2005.03180)\n", + "\n", + "We will not cover the underlying idea behind each approach, for this have a closer look at the papers. \n", + "Instead the focus is on the implementation of operator learning in TorchPhysics. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "sys.path.append(os.getcwd())\n", + "\n", + "import torch \n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given that most operator leaning approaches are data based by default (see [here](https://github.com/boschresearch/torchphysics/tree/main/examples/operator_learning/physics_informed) for physics informed methods), we requiere some data set that is used in training the network.\n", + "\n", + "We provide a small method that creates some right-hand sides $f$ given by random oscillations and computes the \n", + "corresponding solution with a Euler scheme." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from datasets.generate_ode_data import generate_ode_data\n", + "import matplotlib.pyplot as plt\n", + "\n", + "N_train = 10000 # number of training samples (u, f)\n", + "N_time = 100 # number of time steps\n", + "dt = 1.0/N_time # time step size\n", + "\n", + "input_data, output_data = generate_ode_data(N_train, N_time, dt)\n", + "\n", + "# Plot one example\n", + "f, axarr = plt.subplots(1,2, figsize=(9, 2.5))\n", + "axarr[0].plot(torch.linspace(0, 1, N_time), input_data[0])\n", + "axarr[0].title.set_text(r\"Example $f$\")\n", + "axarr[0].grid()\n", + "axarr[1].plot(torch.linspace(0, 1, N_time), output_data[0])\n", + "axarr[1].title.set_text(r\"Example solution $u$\")\n", + "axarr[1].grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In TorchPhysics we have to define the input and output space like in the PINN cases. Here we work with\n", + "functions that get the *time* as an input and output either $f$ or $u$.\n", + "Therefore, we now also define so called **FunctionSpaces** for internally defining what functions should get what variables\n", + "as input and what should the output." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "T = tp.spaces.R1(\"t\")\n", + "F = tp.spaces.R1(\"f\")\n", + "U = tp.spaces.R1(\"u\")\n", + "\n", + "fn_space_F = tp.spaces.FunctionSpace(T, F)\n", + "fn_space_U = tp.spaces.FunctionSpace(T, U)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we need to make the above data ready to be used for training. This follows a similar structure as for PINNs, where we need to define a domain and then a sampler.\n", + "\n", + "Here, we are not working on domains but set of functions instead. So we create a so-called **FunctionSet**, which takes care of moving data to the GPU, the correct input and output shape and more. There are a great number of FunctionSets provided in TorchPhysics. Given that we are using a data-driven approach, we use the **DataFunctionSet** which takes a given data set and prepares it for the trainig process, similar to a Pytorch data set." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "data_functionset_input = tp.domains.DataFunctionSet(fn_space_F, input_data)\n", + "data_functionset_output = tp.domains.DataFunctionSet(fn_space_U, output_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we create some **samplers**, that will sample some functions from the function sets. Again, as for PINNs different kind of sampelers are provided.\n", + "\n", + "Here, we want to randomly sample 2500 functions from the whole data set and pass them on to the model and solver. Since this is a data driven approach both input and output data needs to be sampled. Clearly they should be sampled the same way so the input output ordering $(f, u)$ is not destroyed." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# We take random functions from our input:\n", + "functionsampler_input = tp.samplers.FunctionSamplerRandomUniform(2500, data_functionset_input)\n", + "# The output should be coupled to the correct input functions:\n", + "functionsampler_output = tp.samplers.FunctionSamplerCoupled(data_functionset_output, functionsampler_input)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we need to decided what approach we want to use to solve the problem. As mentioned before different approaches can be used in TorchPhysics. The follwoing three cells each implement one approach. \n", + "\n", + "By default a DeepONet is used, since the other cells are commented out. But we can easily switch to another approach by just commenting out the other approaches." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "### DeepONet\n", + "time_grid = torch.linspace(0, 1, N_time).reshape(-1, 1)\n", + "trunk_net = tp.models.FCTrunkNet(T, default_trunk_input=time_grid, hidden=(30, 30))\n", + "branch_net = tp.models.FCBranchNet(fn_space_F, hidden=(20, 20), grid=time_grid)\n", + "model = tp.models.DeepONet(trunk_net, branch_net, U, output_neurons=40)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "### FNO\n", + "# hidden_channels = 8\n", + "\n", + "# model = tp.models.FNO(F, U, \n", + "# fourier_layers=3, \n", + "# hidden_channels=hidden_channels, \n", + "# fourier_modes=8, \n", + "# skip_connections=True, \n", + "# space_resolution=N_time # this smoothes the output, but removes the super resolution property of FNOs\n", + "# )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "### Model order reduction network\n", + "\n", + "### For this approach we also need to carry out PCA, which is preimplemented in the DataFunctionSet class \n", + "# data_functionset_input.compute_pca(10) # <- the number of PC to use for the input\n", + "# data_functionset_output.compute_pca(10) # <- the number of PC to use for the output\n", + "\n", + "# model = tp.models.PCANN_FC.from_fn_set(\n", + "# data_functionset_input, data_functionset_output\n", + "# )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now have a data set and our model at hand. What we are missing is a condition that tells us what should be learned.\n", + "Since in this case we are only fitting data, we use the **tp.conditions.OperatorCondition**.\n", + "By default this condition use the inputs from our input function sampler, passes them to the model and compare the model output with the data obtained from the output function sampler.\n", + "\n", + "One can pass in customized residual functions if needed" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "data_condition = tp.conditions.OperatorCondition(module=model, \n", + " input_function_sampler=functionsampler_input, \n", + " output_function_sampler=functionsampler_output)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can start to train the network:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), 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", + "You are using a CUDA device ('GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3,4,5,6,7]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 5.5 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "5.5 K Trainable params\n", + "0 Non-trainable params\n", + "5.5 K Total params\n", + "0.022 Total estimated model params size (MB)\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 5000/5000 [00:29<00:00, 168.60it/s, train/loss=4.160] " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_steps=5000` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 5000/5000 [00:29<00:00, 168.59it/s, train/loss=4.160]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), 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: [0,1,2,3,4,5,6,7]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 5.5 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "5.5 K Trainable params\n", + "0 Non-trainable params\n", + "5.5 K Total params\n", + "0.022 Total estimated model params size (MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 10000/10000 [00:57<00:00, 175.18it/s, train/loss=0.0274]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_steps=10000` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 10000/10000 [00:57<00:00, 175.17it/s, train/loss=0.0274]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), 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: [0,1,2,3,4,5,6,7]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 5.5 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "5.5 K Trainable params\n", + "0 Non-trainable params\n", + "5.5 K Total params\n", + "0.022 Total estimated model params size (MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 5000/5000 [00:28<00:00, 175.21it/s, train/loss=0.00854]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_steps=5000` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 5000/5000 [00:28<00:00, 175.19it/s, train/loss=0.00854]\n" + ] + } + ], + "source": [ + "lr_list = [0.01, 0.001, 0.0005]\n", + "step_list = [5000, 10000, 5000]\n", + "\n", + "for i in range(len(lr_list)):\n", + " optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=lr_list[i])\n", + " solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", + "\n", + " trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=step_list[i], \n", + " logger=False, \n", + " enable_checkpointing=False)\n", + "\n", + " trainer.fit(solver)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For evaluation we create a new unseen data set and compare the model output with the expected solution." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Relative error: 3.144257068634033 %\n" + ] + } + ], + "source": [ + "N_test = 1000 # number of test samples (u, f)\n", + "input_test, output_test = generate_ode_data(N_test, N_time, dt)\n", + "\n", + "if isinstance(model, tp.models.DeepONet):\n", + " model_output = model(branch_inputs=tp.spaces.Points(input_test, F)).as_tensor\n", + "else:\n", + " model_output = model(tp.spaces.Points(input_test, F)).as_tensor\n", + "\n", + "rel_error = torch.max(torch.abs(model_output - output_test)) / torch.max(torch.abs(output_test))\n", + "\n", + "print(f\"Relative error: {rel_error*100} %\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Example plot:\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Example plot:\")\n", + "plot_idx = 0\n", + "f, axarr = plt.subplots(1,2, figsize=(9, 2.5))\n", + "axarr[0].plot(torch.linspace(0, 1, N_time), input_test[plot_idx])\n", + "axarr[0].title.set_text(r\"Example $f$\")\n", + "axarr[0].grid()\n", + "axarr[1].plot(torch.linspace(0, 1, N_time), output_test[plot_idx])\n", + "axarr[1].plot(torch.linspace(0, 1, N_time), model_output[plot_idx].detach())\n", + "axarr[1].title.set_text(r\"Solution $u$\")\n", + "axarr[1].grid()\n", + "axarr[1].legend([\"True solution\", \"Predicted solution\"])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tp_version2", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/operator_learning/physics_informed/PI_DeepONet_integrator.ipynb b/examples/operator_learning/physics_informed/PI_DeepONet_integrator.ipynb new file mode 100644 index 00000000..01d93c97 --- /dev/null +++ b/examples/operator_learning/physics_informed/PI_DeepONet_integrator.ipynb @@ -0,0 +1,274 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Physics Informed DeepONet: Solving a ODE for different right hand sides\n", + "In this notebook, we present an introduction to the PI-DeepONet concept in TorchPhysics. \n", + "As an example, we try to learn the integral operator of 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$. Since this a physics informed approach no data is requiered." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torchphysics as tp \n", + "import torch\n", + "import pytorch_lightning as pl\n", + "\n", + "T = tp.spaces.R1(\"t\") # trunk input\n", + "U = tp.spaces.R1(\"u\") # solution\n", + "F = tp.spaces.R1(\"f\") # branch input\n", + "\n", + "branch_space = tp.spaces.FunctionSpace(T, F)\n", + "\n", + "# Given that DeepONet are models that both get a functional and variable\n", + "# input, we also need to define an interval from which we will sample time points.\n", + "domain = tp.domains.Interval(T, 0, 1)\n", + "# We will sample 10 points in the interval [0, 1] and use them as the discretization\n", + "# points for the branch input.\n", + "time_grid = tp.samplers.GridSampler(domain, 10).sample_points()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we need to choose what functions we wnat to consider for the right-hand side. Here we combine different type of functions with the **CustomFunctionSet**:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def custom_fn(t, k):\n", + " return k*t\n", + "\n", + "def custom_fn_2(t, k):\n", + " return k*t**2\n", + "\n", + "def custom_fn_3(t, k):\n", + " return k*torch.cos(t)\n", + "\n", + "K = tp.spaces.R1(\"k\") # parameter to sample for function set\n", + "param_sampler = tp.samplers.RandomUniformSampler(\n", + " tp.domains.Interval(K, -1, 1), 10000\n", + ")\n", + "\n", + "# The appending of functionsets lets us create a functionset with multiple functions\n", + "# that all are combined into one set.\n", + "custom_functionset = tp.domains.CustomFunctionSet(branch_space, param_sampler, custom_fn)\n", + "custom_functionset_2 = tp.domains.CustomFunctionSet(branch_space, param_sampler, custom_fn_2)\n", + "custom_functionset_3 = tp.domains.CustomFunctionSet(branch_space, param_sampler, custom_fn_3)\n", + "custom_functionset = custom_functionset.append(custom_functionset_2)\n", + "custom_functionset = custom_functionset.append(custom_functionset_3)\n", + "\n", + "functionsampler = tp.samplers.FunctionSamplerRandomUniform(\n", + " 5000, custom_functionset, function_creation_interval=100\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# The model:\n", + "trunk_net = tp.models.FCTrunkNet(T, hidden=(10, 10), default_trunk_input=time_grid)\n", + "branch_net = tp.models.FCBranchNet(branch_space, hidden=(20, 20), grid=time_grid)\n", + "model = tp.models.DeepONet(trunk_net, branch_net, U, output_neurons=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As in the PINN-approach we now define the residuals the DeepONet needs to fulfill. The only thing special is, that we\n", + "have to use the **PIDeepONetCondition**, since we also need to pass in a function sampler, that prepares the inputs of the branch net." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def ode_residual(u, t, f):\n", + " return tp.utils.grad(u, t) - f\n", + "\n", + "ode_sampler = tp.samplers.RandomUniformSampler(domain, 1000)\n", + "\n", + "ode_cond = tp.conditions.PIDeepONetCondition(deeponet_model=model, \n", + " branch_function_sampler=functionsampler, \n", + " trunk_points_sampler=ode_sampler, \n", + " residual_fn=ode_residual)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "boundary_sampler = tp.samplers.RandomUniformSampler(domain.boundary_left, 10)\n", + "\n", + "def initial_residual(u):\n", + " return u\n", + "\n", + "initial_cond = tp.conditions.PIDeepONetCondition(deeponet_model=model, \n", + " branch_function_sampler=functionsampler, \n", + " trunk_points_sampler=boundary_sampler, \n", + " residual_fn=initial_residual)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), 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", + "You are using a CUDA device ('GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3,4,5,6,7]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 1.4 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "1.4 K Trainable params\n", + "0 Non-trainable params\n", + "1.4 K Total params\n", + "0.006 Total estimated model params size (MB)\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 0%| | 0/5000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "scale = 0.7\n", + "test_branch_input = (scale * time_grid.as_tensor)\n", + "test_trunk_input = tp.samplers.GridSampler(domain, 1000).sample_points().unsqueeze(0)\n", + "print(test_branch_input.shape, test_trunk_input.as_tensor.shape)\n", + "model_out = model(test_trunk_input, test_branch_input).as_tensor\n", + "\n", + "import matplotlib.pyplot as plt\n", + "plt.plot(test_trunk_input.as_tensor[0], model_out.detach()[0])\n", + "plt.plot(test_trunk_input.as_tensor[0], scale/2.0*test_trunk_input.as_tensor[0]**2)\n", + "plt.legend([\"True solution\", \"Predicted solution\"])\n", + "plt.grid()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tp_version2", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/operator_learning/physics_informed/pino_integrator_1D.ipynb b/examples/operator_learning/physics_informed/pino_integrator_1D.ipynb new file mode 100644 index 00000000..645b3f45 --- /dev/null +++ b/examples/operator_learning/physics_informed/pino_integrator_1D.ipynb @@ -0,0 +1,332 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Physics Informed Neural Operator (PINO): Solving a ODE for different right hand sides\n", + "In this notebook, we present an introduction to the PINO [(paper)](https://arxiv.org/abs/2111.03794) concept in TorchPhysics. \n", + "As an example, we try to learn the integral operator of 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$. Since this a physics informed approach no data is requiered." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import torch \n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the spaces that appear:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "T = tp.spaces.R1(\"t\")\n", + "F = tp.spaces.R1(\"f\")\n", + "U = tp.spaces.R1(\"u\")\n", + "\n", + "input_fn_space = tp.spaces.FunctionSpace(T, F)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create the FNO we want to use to learn the solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "hidden_channels = 16\n", + "\n", + "model = tp.models.FNO(F, U, \n", + " fourier_layers=5, \n", + " hidden_channels=hidden_channels, \n", + " fourier_modes=8, \n", + " skip_connections=True, \n", + " channel_up_sample_network=torch.nn.Sequential(\n", + " torch.nn.Linear(F.dim, hidden_channels),\n", + " torch.nn.Tanh(),\n", + " torch.nn.Linear(hidden_channels, hidden_channels),\n", + " torch.nn.Tanh(),\n", + " torch.nn.Linear(hidden_channels, hidden_channels)\n", + " ),\n", + " channel_down_sample_network=torch.nn.Sequential(\n", + " torch.nn.Linear(hidden_channels, hidden_channels),\n", + " torch.nn.Tanh(),\n", + " torch.nn.Linear(hidden_channels, hidden_channels),\n", + " torch.nn.Tanh(),\n", + " torch.nn.Linear(hidden_channels, U.dim)\n", + " ),\n", + " space_resolution=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to implement the differential equation via loss terms. Since the FNO acts by default on a discrete grid, we need to define this\n", + "grid here:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "N_time = 100 # number of grid points\n", + "time_grid = torch.linspace(0, 1, N_time).reshape(-1, 1)\n", + "step_size = time_grid[1, 0] - time_grid[0, 0]\n", + "time_grid_points = tp.spaces.Points(time_grid.unsqueeze(0), T)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we need to choose what functions we want to consider for the right-hand side. Here, we use a fourier basis given by the\n", + "class **HarmonicFunctionSet1D**." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "harmonic_fn_set = tp.domains.HarmonicFunctionSet1D(\n", + " input_fn_space, \n", + " function_set_size=50000, \n", + " period=1.0, \n", + " max_frequence=4\n", + ")\n", + "\n", + "# The functions are only needed at the discrete grid points\n", + "# so we can discretize the function set:\n", + "discrete_harmonic_fn_set = harmonic_fn_set.discretize(time_grid_points)\n", + "\n", + "# Create a sampler for the function set, that will pass 10000 functions\n", + "# in each trainig step to the model and after 100 steps will create new functions from\n", + "# the function set.\n", + "fn_sampler = tp.samplers.FunctionSamplerRandomUniform(10000, discrete_harmonic_fn_set, 100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To implement the ODE we have to compute the time derivative $\\partial_t$ of the model output. Since FNOs are working on the\n", + "discrete grid, we can not directly use autograd to compute the derivative. Instead we utilize a finite difference scheme to approximate the derivative on the grid.\n", + "For this different methods are implemented in the **utils** section. This is the reason we needed to fix a grid above, such that we now know the grid size." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def ode_residual(u, f):\n", + " u_t = tp.utils.discrete_grad_on_grid(u, grid_size=step_size)\n", + " return u_t - f\n", + "\n", + "ode_condition = tp.conditions.PIOperatorCondition(module=model, \n", + " input_function_sampler=fn_sampler, \n", + " residual_fn=ode_residual, \n", + " weight=0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Also we need to enforce the initial condition:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def initial_residual(u):\n", + " return u[:, 0]\n", + "\n", + "initial_condition = tp.conditions.PIOperatorCondition(module=model, \n", + " input_function_sampler=fn_sampler, \n", + " residual_fn=initial_residual, \n", + " weight=100.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now start training:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), 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", + "You are using a CUDA device ('GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3,4,5,6,7]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | train_conditions | ModuleList | 4.1 K \n", + "1 | val_conditions | ModuleList | 0 \n", + "------------------------------------------------\n", + "4.1 K Trainable params\n", + "0 Non-trainable params\n", + "4.1 K Total params\n", + "0.017 Total estimated model params size (MB)\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 1%| | 19/2000 [00:03<05:51, 5.64it/s, train/loss=38.20]" + ] + } + ], + "source": [ + "lr_list = [0.001, 0.0001, 0.00005]\n", + "step_list = [2000, 2500, 2500]\n", + "\n", + "for i in range(len(lr_list)):\n", + " optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=lr_list[i])\n", + " solver = tp.solver.Solver([ode_condition, initial_condition], optimizer_setting=optim)\n", + "\n", + " trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=step_list[i], \n", + " logger=False, \n", + " enable_checkpointing=False)\n", + "\n", + " trainer.fit(solver)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally check the learned model on unseen data:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max error: 0.22796916961669922\n", + "Rel. error: 7.81789493560791 %\n" + ] + } + ], + "source": [ + "N_test = 1000\n", + "discrete_harmonic_fn_set.create_functions()\n", + "test_fns = discrete_harmonic_fn_set.get_function(torch.arange(N_test))\n", + "\n", + "model_out = model(test_fns).as_tensor\n", + "\n", + "output_data_test = torch.zeros((N_test, N_time, 1))\n", + "test_fns = test_fns.as_tensor\n", + "for i in range(1, N_time):\n", + " output_data_test[:, i, 0] = output_data_test[:, i-1, 0] + step_size * test_fns[:, i, 0]\n", + "\n", + "print(\"Max error:\", torch.max(torch.abs(output_data_test - model_out)).detach().item())\n", + "rel_error = 100.0 * torch.max(torch.abs(output_data_test - model_out))/torch.max(torch.abs(output_data_test))\n", + "print(\"Rel. error:\", rel_error.detach().item(), \"%\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "example_plot = 142\n", + "t = torch.linspace(0, 1, N_time)\n", + "plt.plot(time_grid[0], model_out[example_plot].detach().cpu())\n", + "plt.plot(time_grid[0], output_data_test[example_plot].detach().cpu())\n", + "plt.legend([\"FNO Solution\", \"Ref. Solution\"])\n", + "plt.grid()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tp_version2", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/oscillation/.ipynb_checkpoints/duffing_nonlinear-checkpoint.ipynb b/examples/oscillation/.ipynb_checkpoints/duffing_nonlinear-checkpoint.ipynb deleted file mode 100644 index 2e255406..00000000 --- a/examples/oscillation/.ipynb_checkpoints/duffing_nonlinear-checkpoint.ipynb +++ /dev/null @@ -1,1020 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "cce3e604", - "metadata": {}, - "source": [ - "### PINN approach for the 1-D duffing problem\n", - "\n", - "$\\ddot{u} + 2D\\dot{u} + \\omega_0^2(u + \\mu u^3) = f(t)$" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "034c062f", - "metadata": { - "scrolled": false - }, - "outputs": [], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torchphysics as tp\n", - "import pytorch_lightning as pl\n", - "import pandas as pd\n", - "import numpy as np\n", - "from scipy.integrate import solve_ivp\n", - "from scipy.signal import chirp, unit_impulse\n", - "from scipy.interpolate import InterpolatedUnivariateSpline as IUS\n", - "from torchinfo import summary\n", - "\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "626efd22", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Training on cuda:1\n", - "GPU available: True\n" - ] - } - ], - "source": [ - "device = torch.device(\"cuda:1\" if torch.cuda.is_available() else \"cpu\")\n", - "print('Training on', device)\n", - "print (\"GPU available: \" + str(torch.cuda.is_available()))" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ac4ceb33", - "metadata": {}, - "outputs": [], - "source": [ - "torch.backends.cuda.matmul.allow_tf32 = False\n", - "torch.backends.cudnn.allow_tf32 = False" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "cb96a875", - "metadata": {}, - "outputs": [], - "source": [ - "omega_0 = 1\n", - "\n", - "ode_params = {'D': .1, # damping constant\n", - " 'c_nlin': 0.75 # nonlinearity\n", - " }\n", - "sampling_frequency = 32 \n", - "t_end = 36 # sec\n", - "time = np.linspace(0, t_end, t_end*sampling_frequency + 1)\n", - "time_ind = pd.to_timedelta(time, unit=\"sec\")\n", - "f_fac = 1.\n", - "x0 = [0, 0.5] # initial conditions [x0, v0]" - ] - }, - { - "cell_type": "markdown", - "id": "79bd9b20", - "metadata": {}, - "source": [ - "### ODE solution" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "09f061ee", - "metadata": {}, - "outputs": [], - "source": [ - "def duffing(t, y, D, c_nlin, F_func):\n", - " z1, z2 = y\n", - " dz1dt = z2\n", - " dz2dt = - 2 * D * z2 - z1 - c_nlin * z1**3 + f_fac * F_func(t)\n", - " return(dz1dt, dz2dt)\n", - "\n", - "def interfunc(data, k=1):\n", - " return IUS(data.index.to_numpy().ravel(), data, k=k)\n", - "\n", - "def get_rk_solution(func, t_1, time_eval):\n", - " numeric_solu = solve_ivp(duffing,\n", - " t_span=(0, t_1),\n", - " y0 = x0,\n", - " max_step=1 / sampling_frequency,\n", - " args=(ode_params['D'], ode_params['c_nlin'], func),\n", - " t_eval=time_eval,\n", - " )\n", - "\n", - " solu = pd.Series(numeric_solu.y[0,:], index=pd.Index(numeric_solu.t, name=\"time\"), name=\"Runge-Kutta\")\n", - " return solu" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "65e23108", - "metadata": {}, - "outputs": [], - "source": [ - "chirpfunc = chirp(time, f0=0.1, t1=time.max(), f1=10, method='linear', phi=-90)\n", - "F = pd.DataFrame([np.random.randn(time.shape[0]),\n", - " chirpfunc,\n", - " chirpfunc + 0.5 * np.random.randn(time.shape[0]),\n", - " unit_impulse(time.shape[0]),\n", - "# np.zeros(time.shape[0])\n", - " ],\n", - " columns=pd.Index(time, name=\"time\"),\n", - " index=[\"wn\", \"SineSweep\", \"SoR\", \"Dirac\"]\n", - " ).T\n", - "\n", - "func_f = F.apply(interfunc)\n", - "rk_solu = func_f.apply(get_rk_solution,**{\"t_1\":t_end, \"time_eval\":time}).T" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "288f4187", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([, ,\n", - " , ],\n", - " dtype=object)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "%matplotlib inline\n", - "F.plot(title=\"Right hand site f(t)\", figsize=(15,8), subplots=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "44030304", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([, ,\n", - " , ],\n", - " dtype=object)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "rk_solu.plot(figsize=(15,8), subplots=True, title=\"Runge-Kutta\") " - ] - }, - { - "cell_type": "markdown", - "id": "120841b3", - "metadata": {}, - "source": [ - "### PINN solution" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "7db42f4e", - "metadata": {}, - "outputs": [], - "source": [ - "T = tp.spaces.R1('t') # time\n", - "# Output\n", - "U = tp.spaces.R1('u')\n", - "# Intervals and domains and sampler\n", - "Dmin, Dmax = 0.01, 0.1\n", - "A_t = tp.domains.Interval(T, -0.05, t_end)\n", - "inner_sampler = tp.samplers.GridSampler(A_t, n_points = 2048)#.make_static()\n", - "initial_u_sampler = tp.samplers.GridSampler(A_t.boundary_left, n_points = 1).make_static()\n", - "initial_v_sampler = tp.samplers.GridSampler(A_t.boundary_left, n_points = 1).make_static()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "2e353538", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Points:\n", - "{'t': tensor([[-3.2406e-02],\n", - " [-1.4812e-02],\n", - " [ 2.7818e-03],\n", - " ...,\n", - " [ 3.5947e+01],\n", - " [ 3.5965e+01],\n", - " [ 3.5982e+01]])}" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "inner_sampler.sample_points()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "6e78c8d5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "_eval = \"Dirac\" #\"wn\"\n", - "f, ax = plt.subplots(figsize=(15,8))\n", - "F[_eval].plot(title=\"Right hand site f(t)\", ax=ax)\n", - "F_inter_func = func_f[_eval]\n", - "pd.DataFrame(F_inter_func(inner_sampler.sample_points().as_tensor.numpy().ravel()),\n", - " index=pd.Index(inner_sampler.sample_points().as_tensor.numpy().ravel(),name=\"time\"),\n", - " columns=[\"sample points for PINN\"]).plot(\n", - " # x=\"time\", y=\"sample points for PINN\",\n", - " marker=\"o\",\n", - " color=\"r\",\n", - " linestyle=None,\n", - " linewidth=0.1,\n", - " ax=ax\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "1eb8838f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "=================================================================\n", - "Layer (type:depth-idx) Param #\n", - "=================================================================\n", - "FCN --\n", - "├─Sequential: 1-1 --\n", - "│ └─Linear: 2-1 64\n", - "│ └─DampedSine: 2-2 --\n", - "│ └─Linear: 2-3 1,056\n", - "│ └─DampedSine: 2-4 --\n", - "│ └─Linear: 2-5 528\n", - "│ └─DampedSine: 2-6 --\n", - "│ └─Linear: 2-7 102\n", - "│ └─DampedSine: 2-8 --\n", - "│ └─Linear: 2-9 28\n", - "│ └─DampedSine: 2-10 --\n", - "│ └─Linear: 2-11 5\n", - "=================================================================\n", - "Total params: 1,783\n", - "Trainable params: 1,783\n", - "Non-trainable params: 0\n", - "=================================================================" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#%% Model Definition\n", - "class Snake(torch.nn.Module):\n", - " def __init__(self):\n", - " super().__init__()\n", - " pass\n", - "\n", - " def forward(self, Tensor):\n", - " a = 1\n", - " return Tensor + (1.0/a) * torch.pow(torch.sin(Tensor * a), 2)\n", - "\n", - "class Sine(nn.Module):\n", - " def __init__(self):\n", - " super().__init__()\n", - " pass\n", - "\n", - " def forward(self, Tensor):\n", - " return torch.sin(Tensor)\n", - " \n", - "class DampedSine(nn.Module):\n", - " def __init__(self):\n", - " super().__init__()\n", - " pass\n", - "\n", - " def forward(self, Tensor):\n", - " alpha = 0.1\n", - " return torch.exp(-alpha * Tensor) * torch.sin(Tensor)\n", - "\n", - "model = tp.models.FCN(input_space=T, output_space=U, hidden=(32, 32, 16, 6, 4),\n", - " activations=DampedSine() #Tanh(), RNN()\n", - "# activations=[Snake(), DampedSine(), Snake()] #Tanh(), RNN()\n", - " )\n", - "summary(model, input_size=None)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "d7626839", - "metadata": {}, - "outputs": [], - "source": [ - "def right_hand_side(t):\n", - " rhs = f_fac * torch.tensor(F_inter_func(t.detach().cpu().numpy()))\n", - " return rhs.cuda()\n", - "\n", - "def duffing_residual(u, t, right_hand_side):\n", - " pde_homo = tp.utils.laplacian(u, t) + 2 * ode_params[\"D\"] * tp.utils.grad(u, t) \\\n", - " + omega_0**2 * u + ode_params[\"c_nlin\"] * u**3\n", - " return pde_homo - right_hand_side \n", - " \n", - "pde_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=inner_sampler,\n", - " residual_fn=duffing_residual,\n", - " data_functions={'right_hand_side': right_hand_side},\n", - " name='pde_condition',\n", - " weight=10.0)\n", - "\n", - "def initial_u_residual(u):\n", - " return u - x0[0]\n", - "initial_u_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=initial_u_sampler,\n", - " residual_fn=initial_u_residual,\n", - " name='ic_u')\n", - "\n", - "def initial_v_residual(u, t):\n", - " return tp.utils.grad(u, t) - x0[1]\n", - "initial_v_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=initial_v_sampler,\n", - " residual_fn=initial_v_residual,\n", - " name='ic_v')\n", - "def rhs_residual(u, right_hand_side):\n", - " return right_hand_side - u\n", - "\n", - "rhs_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=inner_sampler,\n", - " residual_fn=rhs_residual,\n", - " data_functions={'right_hand_side': right_hand_side},\n", - " name='rhs',\n", - " weight=12)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3dd9b6e3", - "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: [MIG-GPU-bf355ce4-05d3-bb64-9bee-4f04b006a8ae/12/0]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 1.8 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "1.8 K Trainable params\n", - "0 Non-trainable params\n", - "1.8 K Total params\n", - "0.007 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "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": "c441cccbadba4d6ea8798ba6aaf3fa79", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "gpus_switch = 1 if torch.cuda.is_available() else None\n", - "gpus_switch\n", - "#%% Training\n", - "# for opti, steps in zip([torch.optim.AdamW], [50]):\n", - "for opti, steps in zip([torch.optim.AdamW, torch.optim.LBFGS], [5000, 240]):\n", - " opt_setting = tp.solver.OptimizerSetting(opti, lr=1e-2) #AdamW, SGD, LBFGS\n", - " solver = tp.solver.Solver([pde_condition,\n", - " initial_u_condition,\n", - " initial_v_condition,\n", - " rhs_condition\n", - " ], optimizer_setting = opt_setting)\n", - " \n", - " trainer = pl.Trainer(gpus=gpus_switch,\n", - " max_steps = steps,\n", - " logger=True, \n", - " benchmark=False,\n", - " log_every_n_steps=10,\n", - " )\n", - " trainer.fit(solver)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "b4eb90d6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#%% Prediction\n", - "time_tensor = torch.tensor(time)\n", - "params = {'axes.labelsize': 22,\n", - " 'axes.titlesize': 16,\n", - " 'legend.fontsize': 'x-large'}\n", - "plt.rcParams.update(params)\n", - "grid_sampler = tp.samplers.GridSampler(A_t, n_points=len(rk_solu)) #+ tp.samplers.GridSampler(A_t.boundary, n_points=1)\n", - "grid_points = grid_sampler.sample_points()\n", - " # )\n", - "model_out = model(grid_points)\n", - "pinn_solu = pd.Series(np.interp(rk_solu.index, grid_points.as_tensor.detach().numpy().ravel(), \n", - " model_out.as_tensor.detach().numpy().ravel()),\n", - " index=rk_solu.index, name=\"PINN\"\n", - " )\n", - "solu_comb = pd.concat((rk_solu[_eval], pinn_solu), axis=1)\n", - "solu_comb.plot(marker=None, figsize=(15,4), fontsize=22, ylabel=\"displacement\",\n", - " xlabel=\"time [sec]\", grid=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "ffc85231", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "time\n", - "0.00000 NaN\n", - "0.03125 NaN\n", - "0.06250 NaN\n", - "0.09375 NaN\n", - "0.12500 NaN\n", - " ..\n", - "35.87500 NaN\n", - "35.90625 NaN\n", - "35.93750 NaN\n", - "35.96875 NaN\n", - "36.00000 NaN\n", - "Name: PINN, Length: 1153, dtype: float64" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pinn_solu" - ] - }, - { - "cell_type": "markdown", - "id": "70f19acc", - "metadata": {}, - "source": [ - "### Some validation" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "15f65a1f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 0 1 2\n", - "count 577.000000 577.000000 577.000000\n", - "mean 0.054034 -0.014500 -0.057316\n", - "std 0.946844 1.036568 1.035195\n", - "min -2.975134 -2.630992 -3.594237\n", - "25% -0.589076 -0.686592 -0.742322\n", - "50% 0.067919 -0.006340 -0.018100\n", - "75% 0.728967 0.718518 0.626640\n", - "max 2.695139 2.839369 3.430359\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "tend_val = int(.5 * t_end)\n", - "time_val = np.linspace(0, tend_val, tend_val*sampling_frequency + 1)\n", - "Fval = pd.DataFrame(np.random.randn(time_val.shape[0], 3),\n", - " index=pd.Index(time_val, name=\"time\"),\n", - "# index=[\"wn\", \"SineSweep\", \"SoR\"]\n", - " )\n", - "print(Fval.describe())\n", - "Fval.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "1b607f07", - "metadata": {}, - "outputs": [], - "source": [ - "func_f_val = Fval.apply(interfunc)\n", - "rk_solu_val = func_f_val.apply(get_rk_solution, **{\"t_1\" : tend_val, \"time_eval\" : time_val}).T" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "533faea6", - "metadata": {}, - "outputs": [], - "source": [ - "A_t_val = tp.domains.Interval(T, 0, tend_val)\n", - "grid_sampler = tp.samplers.GridSampler(A_t_val, n_points=len(time_val))\n", - "grid_points = grid_sampler.sample_points()\n", - "pinn_val_pinn = model(grid_points)\n", - "pinn_eval = pd.Series(np.interp(time_val, grid_points.as_tensor.detach().numpy().ravel(), \n", - " pinn_val_pinn.as_tensor.detach().numpy().ravel()),\n", - " index=pd.Index(time_val, name=\"time\"), name=\"PINN\"\n", - " )\n", - "# pinn_eval = pd.Series(pinn_val_pinn.as_tensor.detach().numpy().ravel(), index=grid_points.as_tensor.detach().numpy().ravel())" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "22156ceb", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "pinn_eval.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "421dfbcc", - "metadata": {}, - "outputs": [], - "source": [ - "from scipy.signal import convolve" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "cdc664a3", - "metadata": {}, - "outputs": [], - "source": [ - "# len(time_val)\n", - "u_val = Fval.transform(lambda x: np.convolve(x, pinn_eval, 'same'))\n", - "# convolve(pinn_eval, Fval.iloc[:, 0],\n", - "# mode=\"same\",\n", - "# # mode=\"full\",\n", - "# )" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "cb8fe4ae", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "u_val.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "c39ab52d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
012
time
0.00000NaNNaNNaN
0.03125NaNNaNNaN
0.06250NaNNaNNaN
0.09375NaNNaNNaN
0.12500NaNNaNNaN
............
17.87500NaNNaNNaN
17.90625NaNNaNNaN
17.93750NaNNaNNaN
17.96875NaNNaNNaN
18.00000NaNNaNNaN
\n", - "

577 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " 0 1 2\n", - "time \n", - "0.00000 NaN NaN NaN\n", - "0.03125 NaN NaN NaN\n", - "0.06250 NaN NaN NaN\n", - "0.09375 NaN NaN NaN\n", - "0.12500 NaN NaN NaN\n", - "... .. .. ..\n", - "17.87500 NaN NaN NaN\n", - "17.90625 NaN NaN NaN\n", - "17.93750 NaN NaN NaN\n", - "17.96875 NaN NaN NaN\n", - "18.00000 NaN NaN NaN\n", - "\n", - "[577 rows x 3 columns]" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pd.DataFrame(u_val)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "f3a876ad", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "rk_solu_val.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "c4059df7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(577, 3)" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "rk_solu_val.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "9bb5cefe", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "577" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(time_val)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "84556192", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:.conda-pytorch-physics]", - "language": "python", - "name": "conda-env-.conda-pytorch-physics-py" - }, - "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.6" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/oscillation/.ipynb_checkpoints/duffing_nonlinear-variable_damping-checkpoint.ipynb b/examples/oscillation/.ipynb_checkpoints/duffing_nonlinear-variable_damping-checkpoint.ipynb deleted file mode 100644 index 605f9306..00000000 --- a/examples/oscillation/.ipynb_checkpoints/duffing_nonlinear-variable_damping-checkpoint.ipynb +++ /dev/null @@ -1,686 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "cce3e604", - "metadata": {}, - "source": [ - "### PINN approach for the 1-D duffing problem\n", - "\n", - "$\\ddot{u} + 2D\\dot{u} + \\omega_0^2(u + \\mu u^3) = f(t)$" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "034c062f", - "metadata": { - "scrolled": false - }, - "outputs": [], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torchphysics as tp\n", - "import pytorch_lightning as pl\n", - "import pandas as pd\n", - "import numpy as np\n", - "from scipy.integrate import solve_ivp\n", - "from scipy.signal import chirp\n", - "from scipy.interpolate import InterpolatedUnivariateSpline as IUS\n", - "from torchinfo import summary\n", - "\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "fa8c67b7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 52, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "scipy.signal.chirp" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "626efd22", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Training on cuda:1\n", - "GPU available: True\n" - ] - } - ], - "source": [ - "device = torch.device(\"cuda:1\" if torch.cuda.is_available() else \"cpu\")\n", - "print('Training on', device)\n", - "print (\"GPU available: \" + str(torch.cuda.is_available()))" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "ac4ceb33", - "metadata": {}, - "outputs": [], - "source": [ - "torch.backends.cuda.matmul.allow_tf32 = False\n", - "torch.backends.cudnn.allow_tf32 = False" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "id": "cb96a875", - "metadata": {}, - "outputs": [], - "source": [ - "omega_0 = 1\n", - "\n", - "ode_params = {'D': .1, # damping constant\n", - " 'c_nlin': 0.75 # nonlinearity\n", - " }\n", - "sampling_frequency = 32 \n", - "t_end = 36 # sec\n", - "time = np.linspace(0, t_end, t_end*sampling_frequency + 1)\n", - "time_ind = pd.to_timedelta(time, unit=\"sec\")\n", - "f_fac = 0.75\n", - "x0 = [0, 0.5] # initial conditions [x0, v0]" - ] - }, - { - "cell_type": "markdown", - "id": "79bd9b20", - "metadata": {}, - "source": [ - "### ODE solution" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "id": "09f061ee", - "metadata": {}, - "outputs": [], - "source": [ - "chirpfunc = chirp(time, f0=0.1, t1=time.max(), f1=10, method='linear', phi=-90)\n", - "F = pd.DataFrame([np.random.randn(time.shape[0]),\n", - " chirpfunc,\n", - " chirpfunc + 0.5 * np.random.randn(time.shape[0])],\n", - " columns=pd.Index(time, name=\"time\"),\n", - " index=[\"wn\", \"SineSweep\", \"SoR\"]\n", - " ).T\n", - "\n", - "def interfunc(data, k=1):\n", - " return IUS(data.index.to_numpy().ravel(), data, k=k)\n", - "def get_rk_solution(func):\n", - " numeric_solu = solve_ivp(duffing,\n", - " t_span=(0, t_end),\n", - " y0 = x0,\n", - " max_step=1 / sampling_frequency,\n", - " args=(ode_params['D'], ode_params['c_nlin'], func),\n", - " t_eval=time,\n", - " )\n", - "\n", - " solu = pd.Series(numeric_solu.y[0,:], index=pd.Index(numeric_solu.t, name=\"time\"), name=\"Runge-Kutta\")\n", - " return solu\n", - "func_f = F.apply(interfunc)\n", - "rk_solu = func_f.apply(get_rk_solution).T\n", - "# F_inter_func = F.apply(IUS, #IUS(time, F, k=1)\n", - "\n", - "# numeric_solu = solve_ivp(duffing,\n", - "# t_span=(0, t_end),\n", - "# y0 = x0,\n", - "# max_step=1 / sampling_frequency,\n", - "# args=(ode_params['D'], ode_params['c_nlin'], F_inter_func)\n", - "# )\n", - "\n", - "# solu = pd.Series(numeric_solu.y[0,:], index=pd.Index(numeric_solu.t, name=\"time\"), name=\"Runge-Kutta\")" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "id": "288f4187", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([, ,\n", - " ], dtype=object)" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "%matplotlib inline\n", - "F.plot(title=\"Right hand site f(t)\", figsize=(15,8), subplots=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "id": "44030304", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([, ,\n", - " ], dtype=object)" - ] - }, - "execution_count": 58, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3kAAAIZCAYAAAAbc/Y7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAADXlUlEQVR4nOzdd3hUZdrH8e+TnpAQIAmBJEDovYdeRAVFqYqIYBfsXdeyq6u7q75rW1exIwqooKioIKgoRekl9N4JCaElAdJIP+8fJyi6dDI5M5Pf57rmSjJz5pw7TJg593me576NZVmIiIiIiIiId/BxOgAREREREREpO0ryREREREREvIiSPBERERERES+iJE9ERERERMSLKMkTERERERHxIkryREREREREvIiSPBERERERES+iJE9ERMqVMWa3MeaYMSbbGLPfGDPeGBPqdFwnMsb8wxjz6Qk/xxpjNhtjRhtjzBme+4sxZtSf7rOMMQ1cFa+IiMiJlOSJiIgTBliWFQq0AdoCf3U2nFMzxtQB5gHTLMt6wLIsy+mYRERETkdJnoiIOMayrP3ATKCNMaaXMSblxMdLR/16l37/D2PMF8aYj40xWcaYDcaYhBO2bWeMWVX62JfGmMnGmOdPeLy/MWa1MeaIMWaRMabVmeIzxtTHTvAmWpb1+AlxnDjKF186UudnjHkB6AG8VTpS+ZYxZl7ppmtK7xtmjKlqjJlujDlkjDlc+n3cef9DioiInEBJnoiIOKY0sbkC2H6WTxkIfA5UAaYBb5XuJwD4BhgPVAM+A6464ThtgY+AO4EI4H1gmjEm8DTHqoed4L1vWdYzZxOcZVlPAfOB+yzLCrUs6z7LsnqWPty69L7J2J+/44A6QG3g2PHfRURE5EIpyRMRESd8a4zJApKBg8CzZ/m8BZZlfW9ZVjHwCdC69P7OgB8w2rKsQsuyvgaWnfC8O7CTtaWWZRVbljUByC993qm0ACoBk8/6tzpLlmWlW5Y1xbKsXMuysoAXgIvK+jgiIlIxKckTEREnDLYsKwzoBTQBIs/yeftP+D4XCDLG+AExwN4/rZdLPuH7OsCjpVM1jxhjjgC1gBhjzPWl0yizjTE/nPCcadijf3NK1+WVGWNMiDHmfWNMkjEmE3vEsIoxxrcsjyMiIhWTkjwREXGMZVm/Yk+xfBXIAUKOP1aa8ESd5a72AbF/qnxZ64Tvk4EXLMuqcsItxLKszyzLmlg6jTLUsqwr/hTfI8B07EQvtvTuP8QJ1Pjzr3UW8T4KNAY6WZZVGTg+pfO0lTtFRETOhpI8ERFx2utAH6AAe2SunzHGH3gaON2auRMtBoqB+0oLoAwCOp7w+AfAXcaYTsZWqfQ4YWex7/uAucBsY0w0sBroaYypbYwJ538rgx7AXs93uvvCsNfhHTHGVOPsp6uKiIickZI8ERFxlGVZh4CPgWeAe4CxwF7sEbOU0zz1xH0UAFcDI4EjwA3YI3D5pY8nArdjFzc5jF3o5Zaz3LeFvaZvGTALWIW9Tm8tsKL0OCd6A7imtGrm6NL7/gFMKJ0qei12YhsMpAFLgB/PJhYREZGzYdTuR0REvJExZinwnmVZ45yORUREpDxpJE9ERLyCMeYiY0yN0umaNwOt0AiZiIhUQH5OByAiIlJGGgNfYLc92AlcY1nWPmdDEhERKX+arikiIiIiIuJFNF1TRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIn9MBnI/IyEgrPj7e6TBEREREREQcsWLFijTLsqJO9phHJnnx8fEkJiY6HYaIiIiIiIgjjDFJp3pM0zVFRERERES8iJI8ERERERERL6IkT0RExE1YluV0CCIi4gU8ck2eiIiIN0jOyOWH9fv4ZcshViQdJr+ohMpBflSrFICfrw9+PgZ/Xx9iqgTRu2k0A1rHEOTv63TYIuLBjuQW8MP6/eTkF3FRoygaRoc5HZLLFBYWkpKSQl5entOhXJCgoCDi4uLw9/c/6+cYT7xqmJCQYKnwioiIeKqsvEKembqBb1btBaBJjTA614ugcrA/R3ILOJJbSFFJCYXFFkXFJWzZn0Xq0TyqVQrgpi51uKlLPNUqBTj8W4iIp/lx/T6emLKOo8cKf7vv6rax/K1fUyJDAx2MzDV27dpFWFgYERERGGOcDue8WJZFeno6WVlZ1K1b9w+PGWNWWJaVcLLnaSRPRESkHCVn5HLTR8vYk5HL3b3qM6JjbWpVCzntcyzLYsnODMbO38nrs7bxwbydjOxRj3t61dfInoiclXd+2c7LP26hVVw4/3dVS6qHBTJ+0W7Gzt/F0l0ZfH5H5zO+F3mavLw84uPjPTbBAzDGEBERwaFDh87peUryREREysneI8cY+t5icguK+Oz2znSsW+2snmeMoUv9CLrUj2DrgSxen7WV0bO3MX1NKq8MbUX7Ome3HxGpeCzL4vVZ23hj9jYGtYnhlWtaE+Bnl+V4vG8TrmhRk+vHLmHkhOV8dXdXKged/ZRAT+DJCd5x5/M7qPCKB0rLzuetOdu45t1F3DpuGd+u2ktJiedNuxURqUiKikt48LNVZOcXMfnOLmed4P1Zo+gw3rm+PZ+O7ER+UQlD31vM2Pk7VbRFRE7qtZ+38sbsbQxtH8dr17b5LcE7rmVcOO/d0J6dh3L469frHIpSypqSPA9iWRaTl+/h4ld+4dWftlJUYrEzLYeHJq9m6PuL2bI/y+kQRUTkFEbP3kZi0mFeuKoFTWtWvuD9dW8YycyHe3J58xo8P2MTf/lyLUXFJWUQqYh4i2lrUnlzznau61CLl4a0wtfn5CNCXRtE8nCfRsxYu49pa1LLOUpxBSV5HuJAZh43fbSMJ6aso2lMZX5+uCff3tuNX/7Si1eHtmbnoWwGvrWA2ZsOOB2qiIj8yco9h3lz7nauaR/HoDaxZbbf0EA/3h7RjgcvbciUlSn85cs1mtkhIgBsP5jFk1PW0iG+Ks8NboHPKRK84+7sWY+2tavw92/XcyDTs6tRSjmsyTPG9AXeAHyBsZZlvXiK7YYAXwEdLMtS6cwTrE4+wh0fJ5KVV8S/BjXnhk51fvuPaozhmvZx9GocxW3jl3PnJyv46JYO9GwU5XDUIiICUFxi8fdv1xMdFsQ/BjYv8/37+Bge7tOIAD8fXpm5hejKQfz1yqZlfhwR8RwFRSXcO3EVIQG+vDWiHf6+Zx7X8fP14bVr23DFG/N4bvpG3hrRrhwiLT///G4DG1Mzy3SfzWIq8+yA07+vv/LKKwQGBvLAAw/w8MMPs2bNGubMmcOcOXP48MMPmTp1Kg8++CDTp08nODiYqVOnEh0dfcGxuXQkzxjjC7wNXAE0A4YbY5qdZLsw4EFgqSvj8USzNx1g2PuLCfDz4Zt7u3JTl/iTXomJDA1k4qhO1I8K5aHJq9l39JgD0YqIyJ9NXJrEhtRM/t6/GaGBrru2eu/FDbixcx3en7dT061EKrgP5u9ky4EsXhrSiujKQWf9vLqRlbijZ32mr93HiqQMF0ZYcfTo0YP58+cDkJiYSHZ2NoWFhcyfP5+ePXuSk5ND586dWbNmDT179uSDDz4ok+O6eiSvI7DdsqydAMaYz4FBwMY/bfcc8BLwmIvj8SjLdmVwz8SVNK4RxrhbOhBxhv4lYUH+vHNDOwa+uYD7Jq3i8zs6n9WVGxERcY1DWfm8MnML3RtEcmXLGi4/3t/7N2PL/iwe/2oN9aMq0Twm3OXHFBH3knI4l9Gzt3Flyxpc2vTcR4Tuuqgeny/bwwszNjHl7q5eUZ0SOOOIm6u0b9+eFStWkJmZSWBgIO3atSMxMZH58+czevRoAgIC6N+//2/b/vzzz2VyXFdnALFA8gk/p5Te9xtjTDuglmVZM063I2PMHcaYRGNM4rn2ifBEadn53DNxBbFVgxl/a8czJnjH1Y8K5d9DWrEi6TCvzNzi4ihFROR0/v3DJvIKi/nnoOblcqIU4OfD29e3o2pIAHd8vIKMnAKXH1NE3Mt7v+6gxLJ4ut//TJ47KyEBftx/aUNW7jnCoh3pZRxdxePv70/dunUZP348Xbt2pUePHsydO5ft27fTtGlT/P39f/t88PX1paioqEyO6+gwjzHGB3gNePRM21qWNcayrATLshKiorx7vZllWTz+1Voy84p474b2VKsUcE7PH9g6hhGdavPB/J1sSD3qoihFROR0lu/O4OuVe7m9Rz3qR4WW23GjwgJ574b2HMrO596JK1VxU6QCOZCZxxeJKVzTPo6YKsHnvZ+h7eOoHhbIW3O2l2F0FVePHj149dVX6dmzJz169OC9996jbdu2Lr345+okby9Q64Sf40rvOy4MaAH8YozZDXQGphljElwcl1v7dEkSczYf5G9XNKFRdNh57eOJvk2oEuzPCzM2qXeSiEg5syyL52dsomZ4EPdd0qDcj9+6VhX+fVVLFu9M5/++31zuxxcRZ3wwbyfFJRZ3X3Rh7ztB/r7c3qMei3ems36vBgwuVI8ePdi3bx9dunQhOjqaoKAgevTo4dJjujrJWw40NMbUNcYEANcB044/aFnWUcuyIi3LircsKx5YAgysyNU1tx/M5vkZm7ioURQ3d40/7/2EB/vz4KUNWbQjnfnb0souQBEROaOZG/azJvkID/duREiAywtZn9SQ9nHc2i2ejxbu4ttVe8/8BBHxaBk5BUxcuoeBrWOoHRFywfu7NqEWgX4+fL58TxlEV7FdeumlFBYWUqlSJQC2bt3KI488AkB2dvZv211zzTWMHz++TI7p0iTPsqwi4D5gJrAJ+MKyrA3GmH8ZYwa68tieqKTE4okpawkO8OWVoa0ueAh3RKc6VA8LZOyCXWUUoYiInElRcQmvzNxCg+qhXN2u7HrinY+/XdmUhDpV+df0jRw9VuhoLCLiWh8t2EVeUTH39KpfJvsLD/HnypY1mboqlWMFxWWyTyk/Ll+TZ1nW95ZlNbIsq75lWS+U3veMZVnTTrJtr4o8ivfJkiRWJB3mmf7NqB529uVuTyXAz4ebu8Yzb+shtuzPKoMIRUTkTKasTGHHoRz+cllj/ByucOzv68M/BjbncG4B78zV2hoRb3U0t5AJi3bTt3kNGp7nUp+TGdahFln5RXy/bl+Z7VPKh+rru4m9R47x8o+b6dkoiqvalt2V3xEdaxPk78O4hRrNExFxtbzCYl6ftY02tapwefMLb2ZbFlrEhnN12zjGLdxNckau0+GIiAt8uHAXWflFPHBpwzLdb6e61agbWYnJy5PPvLGb8obaFOfzOyjJcxOv/bSVohKLFwa3KNNKO1UrBTCodSxTV6eSmaepOiIirvTJ4iT2Hc3jib5N3Kq31GOXN8bHB179Sa11RLzN0WOFjFu4i8ubR9O0ZuUy3bcxhmsTarFsdwa70nLKdN/lISgoiPT0dI9O9CzLIj09naCgc5vl58xqcPmD7Qez+GZVCqN61KNWtQtfKPtnN3apw+TEZL5ekcIt3eqW+f5FRAQy8wp5+5ft9GwURZf6EU6H8wc1woO4uUs8H8zfyUO9G1E3spLTIYlIGRm3cBdZeWU/infcVW1jeXnmZr5dtZeH+zRyyTFcJS4ujpSUFDy9x3ZQUBBxcXHn9BwleW7gv7O2ERLgx10Xlc1C2T9rERtO61pV+HTpHm7uGu9WV5dFRLzFmF93ciS3kMcvb+x0KCc1skddxi/azTtzt/PK0NZOhyMiZeDosUI+XLCLy5pF0zwm3CXHqBEeRJd6EUxdvZeHejf0qPPI443IKyJN13TYrrQcfli3jxu71Dnnpufn4oZOtdl+MJslOzNcdgwRkYrqYFYeHy7YxYDWMbSIdc2J1oWqHhbE8I61+WbVXq3NE/ES4xfuduko3nGD28SyOz2X1clHXHocKTtK8hw2Zt5O/Hx9uM3F0ygHtI4hPNifT5cmufQ4IiIV0Zuzt1NYXMKjbj6V6c6L6mEMvD9vh9OhiMgFyswr5MMFO+ndNNrlF5f6tqxBgJ8PU1enuvQ4UnaU5DnoYGYeU1akMLR9HFFhgS49VpC/L0PbxzFz/X4OZuW59FgiIhVJUnoOny3bw7AOtYh387VuNcODuaZ9Lb5YnsL+o/osEPFk4xfuJjOviId6u3YUD6BykD+9m1bnuzWpFBWXuPx4cuGU5Dnoo4W7KSop4Y6e9crleNd3rkNRicUXHlwGV0TE3bz281b8fA0Puni6VFm5+6L6FFsWY+btdDoUETlPWXn2WrzeTauX2xTxga1jSc8pYPHO9HI5nlwYJXkOyS0oYtLSJPq2qEGdiPK58ls3shLdG0Ty2bJkSko8t5SsiIi72LQvk6mrU7mtW12qVz638tZOqR0RwuA2sUxalkRadr7T4YjIeZiwaDdHjxXy4KXlN0W8V+MoKgX4MmOtGqN7AiV5Dvl65V4y84pcvhbvz4Z1qMXeI8dYoqswIiIX7I1Z2wgL9OPOnq6pjuwq91xcn/yiEsbO3+V0KCJyjrLyCvlg/i4ubVKdlnHlV+gpyN+X3s2i+XHDfgo1ZdPtKclzgGVZjF+0m5ax4bSvU7Vcj92nWTRhQX58tSKlXI8rZ5ZbUMShrHxSDuey41A2h3MKnA5JRE5jY2omP27Yz63d6xIe4u90OOekflQo/VrW5JPFuzmSq/caT2ZZFrvTctiTnktBkU68K4KPFyfZo3jlsBbvz/q1rMmR3EIW7dBggbtTnzwHzN+WxvaD2bx2bety7zUS5O9L/1YxfLtqL/8aXERooP4EyoNlWew4lE1adgFHjxVy9Fgh+47kkZSew+70HJLSc0k/SVIXGRpI29pVaFu7Cu1rV6V9nar4+erajIg7eGP2VsKC/BhZzjMyysp9lzRg+tp9jFu42+MaHFd0JSUWv2w9yPS1+1i4PY0Dmfa0W39fQ93ISlQO8ic4wJdKAX4kxFdlQOsYoj1kOrGcXnZ+ER/M38nFjaNoFVel3I/fs1EUoYF+zFibykWNosr9+HL2dIbvgHELdxEZGki/VjUdOf417WP5bNkefli3j6EJtRyJoSJZtCONZ6duYNvB7P95LCY8iDoRlbiseTRxVUMIC/IjyM+XQH8fDmXlszE1k1XJR/h54wEAIioFcE1CHLd1q6sPbBEHbUg9yswNB3jw0oYeN4p3XJMalbmsWTTjFu5iVI+6hAV55u9RkViWxTer9vLmnO3sSsuhaog/XRtE0rV+BAG+PuxMy2H7wWxy8ovIzCsiOSOXHzfs54XvN9GlXgTDOtRiQKsYfHw8p5m1/NHY+Ts5klvIg72duTAT5O9Ln2bRzNxwgOcHlxDgpwvP7kpJXjnbeSibuVsO8VDvhgT6+ToSQ7vaVakbWYkpK1OU5LmQZVm8OWc7/521lTrVQvj31S2pUy2EysH+hAf7ExUWSJD/2f0NHM4pYMnOdKatSeWDeTsZt2A3t3SL56HeDQkJ0H9jkfL2xqxthAX5cVt3zxzFO+6+Sxrw08YDfLw4iXsvbuB0OHIaxwqKueOTROZvS6N5TGVGD2/LFS1q4H+G2R07DmUzbXUqU1fv5cHPVzN2/i7+O6wNDaqHllPkUlaSM3J595cd9GtVkza1qjgWR7+WNflm1V4W7kjj4sbVHYtDTk/pdzkbv2g3Ab4+XN+pjmMxGGMY0i6WJTszSM7IdSwOb/efn7by2s9bGdwmlu8f7MHwjrXp2iCSFrHh1KoWctYJHkDVSgFc0bIm797Qnrl/6cXgtjGMmbeTPq/NI3F3hgt/CxH5sy37s/hp4wFu7VaX8GDPHv1qFVeFS5pUZ8y8nWTmFTodjpxCYXEJ90xcwYLtaTw3qDnf3dedga1jzpjggb3+8uE+jZjzaC9eH9aGvUeOMeitBczdcrAcIpey9PyMjfj6GJ7u19TROHo0iiQs0E9VNt2cy5M8Y0xfY8wWY8x2Y8yTJ3n8EWPMRmPMWmPMbGOMc9mPi2XlFfLVihT6t67p8ubnZ3JVuziMsat8Stn7fNke3pq7nes61OI/Q1uX6WhbnYhKvHxNa766qwv+voYbP1zGou1pZbZ/ETm9d37ZTkiAL7d2jXc6lDLxSJ9GHD1WqEqbbqqkxOIvX65h7pZD/N9VLbmxS/x5Tbf08TEMbhvLjAe6Ex9ZiTs/XvHbUgBxf8t2ZTBzwwHu6VWfmuHBjsYS6OdLn+bR/LRhv4r9uDGXJnnGGF/gbeAKoBkw3BjT7E+brQISLMtqBXwFvOzKmJz07aq95BYUc1OXeKdDIbZKMF3qRfD1qhQsSz3zytKqPYd5ZuoGejSM5IWrWrps7UNCfDW+vKsrtauFcNuE5SxVWwwRl0tKz+G7Nanc0LkOVSsFOB1OmWgRG86VLWvw4fydZKiqr1uxLIt/fLeBqatTebxvY4Z3rH3B+6wZHsykUZ1pWjOMuz9dwY/rNRrj7kpKLF6YsZEalYMY2b2e0+EA9pTNzLwiFmw/5HQocgquHsnrCGy3LGunZVkFwOfAoBM3sCxrrmVZx+cMLgHiXByTIyzLYuLSPbSIrUzrcuxpcjrXtI8jKT2XxKTDTofiNdKy87n705VUrxzI6Ova4uvixe1RYYFMvL0TsVWCuW38cmbpqqyIS7336w78fH0Y5eFr8f7skT6NOFZYzLu/bHc6FCmVX1TMo1+s4ePFSdzRsx53X1R2vRjDQ/z5ZFQnWsWFc++kVUxfm1pm+5ayN33dPtakHOXRyxoRHOBMPYc/694wkkoBvvy8UdN+3ZWrk7xYIPmEn1NK7zuVkcAPJ3vAGHOHMSbRGJN46JDnXTVYkXSYzfuzuL5TnXJvm3AqfVvUoFKAL18lqmdeWSgusXjw81Uczi3gvRval9tV/sjQQCbd3pl6UaGM+jiRN2Zto6REo7MiZW3/0Ty+WpHCtQlxVPey6rYNqodxdbs4JixOIvXIMafDqfDSsvMZ8cFSvl61l0f6NOKvVzQp83OHykH+fDyyE+1qV+GBz1YxdbWWb7ijgqISXp25hSY17P+j7iLQz5ceDaOYu/mgZoS5KbcpvGKMuQFIAF452eOWZY2xLCvBsqyEqCjP68sxcekewgL9GNg6xulQfhMS4McVLWsyY90+jhUUOx2Ox3t91lYWbk/nuUEtaBFbvqO10ZWD+PKuLlzdLpb/ztrKvZNWkleo11SkLI2Zt5MSC+7sWXYjKu7kod4NwbLfy8Q5m/dnMuithWxIPcrbI9rxwKUNXXZxODTQjwm3daRj3Wo8PHk1X63QRV9380ViMnsycnmibxOXzw46V5c0qc7+zDw27st0OhQ5CVcneXuBE2v0x5Xe9wfGmN7AU8BAy7LyXRxTucvMK2TGun0MbhtLJTdrPj6kXRzZ+UX8tHG/06F4tPnbDvHmnO0MbR/HtR2caUsR5O/Lf4a25ul+Tflh/X5uG7+c7PwiR2IR8Tbp2flMWpbEoDYx1KoW4nQ4LhFXNYQbOtdhysq97E7LcTqcCmnO5gMMeWcRRSUlfHFnl3LppxsS4Me4WzrStX4kj321hsnL97j8mHJ28gqLGT17Gwl1qtKrsfsNcPRqYsc0Z5OmbLojVyd5y4GGxpi6xpgA4Dpg2okbGGPaAu9jJ3he+Vcyc71dfeiqdqebqeqMTnWrEVslWFfvLsChrHwenryGRtGh/GtQC0djMcYwqkc9/jO0NUt3ZXD9B0s4rEIKIhds3MLd5BeVcE8v7+4ld1evevj5GN6aq7V55W3u5oPc+ckK6kZVYuq93WkVV6Xcjh0c4MvYmxPo2TCKJ6as49MlSeV2bDm1CYt2czArn8cub+w2S31OVD0siNZx4cxROw635NIkz7KsIuA+YCawCfjCsqwNxph/GWMGlm72ChAKfGmMWW2MmXaK3XmsaWtSqVUtmLYONq48FR8fw5D2cSzYnsa+o1qHca6Ol7bOyivkzeHt3GZB9JD2cbx3Q3s27c/i2vcXs/9ontMhiXiszLxCJizezRUtanh9A+nqYUFc36kO36zaS1K6RvPKy5Kd6dz16QoaRYcx6fbO1Agv/zWfQf6+vH9jey5tUp2nv13PhEW7yz0G+V1mXiHv/rqDno2i6FQvwulwTumSJtGsTj5CWrbXTcTzeC5fk2dZ1veWZTWyLKu+ZVkvlN73jGVZ00q/721ZVrRlWW1KbwNPv0fPkpadz6Id6QxoFeOWV2EAhrSLxbLgm1VadH2uPlywi1+3HuLv/ZvRuEaY0+H8QZ9m0Uy4tSP7juYx5N1F7NL0K5Hz8tnSPWTlFXn9KN5xd11kj+a9rdG8crEm+QijJiQSVzWYj2/rSOUgf8diCfL35d0b2nNZs2ienbaBsfN3OhZLRTd23k6O5Bby2GWNnQ7ltC5pUh3Lgl+2eF5RRG/nNoVXvNUP6/ZRXGIxsI37FFz5szoRlegQX5UpK9Qz71ys33uUl2du5ooWNbi+04X3LnKFLvUj+Oz2zhwrLOaadxexRL30RM5JcYnFJ0uS6FS3WrkXVHJK9cpBDO9Ym69X7iU5I/fMT5DztmV/FjePW0bVSv5MHNWZiNBAp0MiwM+Ht69vx5Uta/D8jE18ME+JXnk7mJXHB/N30a9VTVq6SdutU2keU5nqYYHM2awWTu5GSZ6LTVuTSqPoUJrUqOx0KKc1pF0cOw7lsDr5iNOheITC4hL+8uUaqlUK4MWrW7ntKC1Ay7hwvryrC+Eh/lw/dikfzNupZF7kLM3ZfJCUw8e4pWu806GUq7t71cdHo3kutf9oHjd/tIwAXx8mjnRmiuap+Pv6MPq6tvRrVZMXvt/E+IW7nA6pQvnvz9vs8ww3H8UDe9nPJU2qM39rGgVFJU6HIydQkudCe48cY/nuw27VNuFUrmxVkyB/H6asVAGWszFm3k4278/iuUEtCA9xbmrN2aofFcrUe7vRp2k0L3y/iZvHLWfzfpU8FjmTCYt2UzM8iD7Nop0OpVxFVw5ieIdafLUiRaN5LpCTX8TICcvJyitk/K0dqR3hfhVb/Xx9eH1YGy5vHs0/p2/k+3X7nA6pQli2K4PPlu3hpi7x1I2s5HQ4Z+XiJtXJyi8icXeG06HICZTkudD0NakADPCAJK9ykD+XN6/Bd2v2qb/aGRzIzOOtOdvp27wGlzWv4XQ4Zy0syJ93b2jHswOasWrPYfq+Pp97Jq4gXYulRU5q+8EsFmxP4/pOtfHzrXgfl3f1qo+PMbzzi0bzypJl2QW7Nu3L5K0R7WgW474zffx9fXjjura0q12VhyavZrlO4l0qr7CYJ6esJa5qMH+5vJHT4Zy17g0iCfD1YfZmVdl0JxXvU6scTVuTSuu4cOpEeMaVmKvbxXH0WKEWz57Baz9tpaikhL9e2cTpUM6ZMYZbu9Vl3mMX88ClDZm18SB935jP+r1HnQ5NxO18vDiJAF8fruvonmtuXa1meDDDOtTiy8QUUg5rNK+sfLNqLz+s38/jfZtwcZPqTodzRkH+voy9KYHYKsHcM3Glqii60JtztrEzLYcXr25FSIB79VU+nUqBfnSpH8HPGw9oOYgbUZLnIjsOZbMhNdMjRvGO61Y/gohKAXxXOgIp/2vTvky+WJHMTV3iPSZ5P5mqlQJ4pE8jpt7XzT6JHbOEhdvTnA5LxG3k5BcxZUUK/VvVJNINimE45e5e9TEG3vllh9OheIW9R47x7LQNdIivyu096jkdzlmrWimAd65vx9FjhfzlyzWUlOhEvqztSsvhg3m7uLpdLN0bRjodzjm7vHkN9mTksnl/ltOhSCkleS4ybXUqxnjGVM3j/Hx9uLJlTWZvPkB2fpHT4bilV2duISzQj/sv8Y5S6k1rVmbK3V2JrRLMLeOWac2FSKkZ6/aRU1DMCDetnFteYqoEc21CLb5MTGbvEfVSvRBFxSU89PkqLAv+M7QNvj7uW7DrZJrWrMzf+zfjly2H+HCBCrGUteenbyTAz4cn+3reLCGw2zYZAzM37Hc6FCmlJM8FLMviuzWpdKpbjejK7lMt62wMbBNDXmEJszaqFO6fbdmfxezNBxnZvR5VQgKcDqfM1AgP4ou7utA6rgr3TlrJpKV7nA5JxHFfJaZQL7IS7etUdToUx91zsX1R612tzbsgo+dsZ/nuw7xwVQu3LLRyNm7oVJvLm0fz0o+bWaNq3GXmly0Hmb35IPdf0oDqHnbeeFxUWCDta1dl5gadP7oLJXkusCE1k51pOQxsHet0KOesfe2qxIQHMU1TNv/H+/N2EOzvy01d6jgdSpkLD/bnk5Gd6NUoir99s47XZ23VvPpyll9UzO60HDLzCp0OpcLblZbDst0ZDGkf59btUcpLbJVgrmlfiy+Wp7DvqEbzzseSnem8NWcbQ9rFMaiN550bHGeM4eUhrYmuHMT9n60iS+9XF6y4xOL/vt9EfEQIt3ar63Q4F+Ty5jXYtC9TFXndhJI8F5i2JhU/H8MVLTyn8uJxPj6GAa1jmLf1EIdzCpwOx23sPXKMaatTua5jLapW8p5RvBMFB/gy5qYErmkfx+uztvHXr9dRVKyeN6627+gxHp68mjb//Jler/5Cq3/8RM+X5/LM1PWsTTmiZNsBX61IxsfY/UPFdk+v+pRYFu9qbd45O5xTwMOTV1MnohL/GtTc6XAuWHiIP29c14aUw7k8O3WD0+F4vK9XprD1QDaP921CgJ9nn5ZfXlpxXFM23YNn/zW5oZISe6pmz0ZRHpsMDGgdQ1GJxQ/r9Z/0uA/n78ICRnb37KtsZ+Lv68Mr17Tivosb8PnyZB75QgvsXWnO5gP0eW0eM9bt4+p2sbx8TSue6NuEJjXCmLw8mYFvLeSy/85jzLwdqmhXTopLLKas2EvPRlFu1ZzaabWqhXBN+zg+X5bM/qN5TofjMSzL4okpa0nLzufN4W2pFOg5FRNPJyG+Gvdf0pCvV+1l6uq9TofjsfIKi3l91jZaxYV75MDAn9WOCKFpzcpK8tyEkrwylph0mH1H8zyiAfqpNI+pTL3ISkxbozdugCO5BXy+fA8DW8cQV9Uz11GcC2MMf7m8MY9d3phpa1L576ytTofkdSzLYuz8nYyakEidiBBmPXwRL1zVkmsTanF3r/qMuSmB5U/35t9XtyQsyI//+34zXf49m3snrWTh9jQl3i60YHsa+zPzGNq+ltOhuJ17L25AiWXx3q8azTtbny5J4qeNB3iibxNaxIY7HU6Zuv+SBrSvU5Wnv1mv6Xnn6dMlSew9cown+jbxmqnhlzePJjHpMIeydGHSaUryyth3a1IJ8vehT7Nop0M5b8bYUzaX7srQFVvgs2XJ5BYUc0dPzyl3XRbu6VWfYQm1eHPOdqasSHE6HK+RlVfIX75cy/MzNnFZsxp8eVeXkxZhqBzkz/COtfn6nm7MeqQnN3WJZ+H2NK4fu5SL//ML7/6yQx+iLvBlYjJVQvzp3cz9+5eVt1rVQhjSLo5Jy/ZwIFOfDWeyeX8mz83YRK/GUdzm4WutTsbP14fXh7UB4OHJqzW9/xxl5RXy9tzt9GgYSbcGntcy4VQub14Dy4KfVcDPcUryylBRcQnfr9vHpU2jPX5KxsA2MVgWTF9bsQuwFJdYfLokiS71Imhas7LT4ZQrYwzPX9WCrvUj+OvX61i557DTIXm8xN0ZXPHGfL5ZlcIDlzbknevbnVXD2wbVw/h7/2Ys+eulvHFdG2pUDuKlHzdz0Stz+XzZHq3bKyNHcwv5aeMBBrWOIdDP1+lw3NK9FzeguESjeWdyrKCY+yetonKQP68ObY2Ph7VLOFu1qoXw3OAWJCYd5q25qr56Lj5flszh3EIeu7yx06GUqSY1wqhdLURTNt2AkrwytHBHOuk5BR49VfO4+lGhNI+pzHdrK3bftDmbD7L3yDGvrKh5Nvx9fXh7RDtqVgnijo9XqLLeBZi2JpURHyzF18fw5V1deKRPo3M+8Qvy92VQm1gm39mFWY9cRJtaVXjy63U8P2OTEr0yMG3NXgqKShiaoKmap1I7IoSr28YyaekejSSfxnMzNrLtYDb/HdaayNBAp8NxqcFtY7mqbSyjZ29jRVKG0+F4hJISi4lLk0ioU5VWcVWcDqdMGWO4vHk0i3akcfSYqq86SUleGZq2OpWwID96NY5yOpQyMbB1DGuSj5CUnuN0KI75ePFuaoYHefT02wtVtVIAY29KIK+wmNs/TuRYQbHTIXmUvMJi/jFtAw98too2taow9d5utK9T7YL326B6KJ+O7MQtXeP5cMEu/v3D5jKItmL7ckUKTWqE0TymYo3an6u7e9Unv6iET5YkOR2KW5q6ei+Tlu7hrovq06Ohd5wPnMm/BjWnZngwT32zXtM2z8LCHWnsTs/lhs7eeQH5ypY1KSy21HPZYS5P8owxfY0xW4wx240xT57k8UBjzOTSx5caY+JdHZMr5BUW89OG/fRtXsNrpvn0Lx2R/K6C9szbfjCb+dvSuL5Tbfx8K/b1kIbRYbxxXRs2pGbywOerKFbhj7OScjiXoe8tZvyi3dzWrS4fj+xIlZCyq7rr42N4dkAzbupShzHzdjJu4a4y23dFsy7lKGtTjjKsQy2vKYDgKvWiQrm0SXUmLkkir1AXfU60OvkIj3+1lo7x1XikTyOnwyk3YUH+PN2vKZv3Z/H58mSnw3F7ny5JolqlAK5o6fkVNU+mTa0qxFYJZsa6ij0bzGkuPXM1xvgCbwNXAM2A4caYZn/abCRw2LKsBsB/gZdcGZOr/LLlIFn5RQxs4/lTNY+LrRJMQp2qFbYx+qdLkgjw9eG6jrWdDsUtXNo0mmf7N+PnjQf4z09bnA7H7SWl5zD0vcXsTsthzI3teWZAM4L8y/4CkDGGZwc057Jm0fxr+kZ+VOuT8/Lx4t2EBPhytXrjnZWR3euSnlOg8vknWJdylJs/Wkb1yoG8d2N7j+95dq76tqhBp7rV+M9PWziaq2l6p7L/aB6zNh1kaEKc1wwK/Jkxhitb1mD+tkOasukgV78DdQS2W5a107KsAuBzYNCfthkETCj9/ivgUuOBl1GnrUklMjSALvUinA6lTA1sE8PWA9ls3p/pdCjlKju/iCkrUriyZQ2vX09xLm7pVpdhCbV499cdLN+ttRenkpyRy/AxSzhWWMzkO7twWXPXXq319TG8cV1b2tSqwoOfr2JFkorknIvDOQVMW5PK4LaxhAf7Ox2OR+hSP4ImNcL4cMEurQfFHsEbMXYJYUF+TBrVmWoe2if3QhhjeGZAM44eK+SN2ducDsdtfbZsDyWWxfUdvXOq5nH9WsVQWGypyqaDXJ3kxQInjtunlN530m0syyoCjgL/kykZY+4wxiQaYxIPHTrkonDPT1FxCWtTjtKvZU2vm9Z3Zcua+PoYpq2uWKN536zaS1Z+ETd1jXc6FLfz9wHNiKsazKNfrCEnv8jpcNxOckYu141ZQk5BMRNHdaJZOa3vCg7wZexNCdQMD2LUhOXsSqu4a2nP1cSlSeQXlVTYAkvnwxjDyO512XogmwXb05wOx1E7D2Vz67hlVA0JYPKdXahVzfv7qZ5K85hwhnWozceLd7P9YLbT4bidwuISPl++h54No07aOsebtI4Lt6dsVvAq7U7ymIzEsqwxlmUlWJaVEBXlXguZ/Xx9+PWxi3nUy8rgAkSGBtK1fgTfrU2tMFdrLcvi40W7aRkbTttaVZwOx+2EBvrxn6FtSD6cy/99v8npcNzK5v2ZXPPeIrLzi5g4qhPNY8q3+XFEaCDjb+2IMYa7Plmh9VJn4VhBMeMW7ubixlE0qaGCK+diYJsYIkMD+WhBxV0LevRYIbeOX46PMXwysiOxVYKdDslxj17WiGB/X56fsdHpUNzO7E0HOJCZ77UFV05kjKFfq5os2J6m6bsOcXWStxc4sRZ1XOl9J93GGOMHhAPpLo6rzPn6GCoHeec0n4GtY0jOOMbq5CNOh1IuFu9MZ9vBbG7sUkcFGE6hY91q3N6jHhOX7mHuloNOh+O4gqISRs/exsA3F1JiwRd3dqFFbPkmeMfFR1bitWtbs+VAFv/8TidZZ/JFYjLpOQXc3auB06F4nEA/X27sXIe5Ww5VyFEby7J4/Ks17D18jDE3tadORCWnQ3ILkaGBPNi7Ib9sOcTczfp8ONGnS/YQEx7EJU2qOx1KuehXWmXzp41aK+4EVyd5y4GGxpi6xpgA4Dpg2p+2mQbcXPr9NcAcq6IMGXmIy5rXIMDXp8IUYPlkcRJVQvy9ot+hKz3SpxGNokN54qu1HM4pcDocxyzcnsaANxfw2s9buax5ND882IPGNcIcjalX4+rceVE9Plu2hx9U3eyUCotLGDNvJ+3rVKVDfFWnw/FI13euTYCfT4Ws7PrRwt3M3HCAJ69oUiZtUbzJTV3iqRdZiedmbKRQLRUA2JWWw4LtaQzvWBvfc+yR6qlaxYUTVzW4wvdcdopLk7zSNXb3ATOBTcAXlmVtMMb8yxgzsHSzD4EIY8x24BHgf9osiLPCg/25pEl1pq1OpaDIu9+sUw7n8tPGAwzrUMsllRC9SZC/L69d24bDuQX8fep6p8Mpd5v2ZXLTR8u4fuxSsvOLGHtTAm+NaOc2hXr+clljWseF88SUtezW+ryTmr42lb1HjnFPr/oatT9PkaGBXNUmlikrUyrUxZ6dh7J58YdN9GkWzcjudZ0Ox+0E+PnwdP+m7DyUw8eL1U8RYOKSJPx8DMM61jrzxl7CGMPA1jEs2HaIQ1n5TodT4bh8TZ5lWd9bltXIsqz6lmW9UHrfM5ZlTSv9Ps+yrKGWZTWwLKujZVk7XR2TnLthHWqRnlPArE3eXSXp+IfRTV3inQ3EQ7SIDeeh3o2YvnYfU1akOB1OucjMK+Qf0zbQb/R81iQf4akrmzL70Yvo3Sza6dD+wN/Xh9HD2+LrY7jxo6UczMxzOiS3UlJi8e4vO2gcHcbFjSvG1ClXua17XfIKS5i0bI/ToZQLy7J4dtoGgvx8+b+rWuoCwSlc3Lg6PRtF8fqsraRnV+wT/LzCYr5ckcLlzWtQPSzI6XDK1VVtYymx7ItqUr48pvCKOKtnoyhqhgd5dZPTnPwiPlu2h74tamjx/Dm466L6dKpbjb9PXe/V63KKSyw+X7aHS179lQmLd3N9pzrMe+xibu9Zz21HfetEVGLcrR1Jzy7gpo+WqV/RCeZsPsjWA9nc3as+PhVk6pSrNK4RRo+GkXy8eLfXz/YA+29n/rY0HrmsEVFh7jFy746MMTzTvym5BcW8+MNmp8Nx1PS1+zh6rJDrO1e8vrsNo8NoVrMy31awKu3uQEmenBVfH8PQhFrM33aIlMO5TofjEl8mJpOVV6SpN+foeI+2YH9fbh2/jINZ3jditHB7Gv1Gz+fJr9cRHxHC1Hu78dzgFoSHuH+xpTa1qjDmxgR2HMpm1ITlHCtQxU3Lsnjnl+3EVQ2mf6uaTofjFW7rXpcDmfl87+VrQC3L4r+ztlK7WkiFqJB4oRpUD+P2HvX4ckUKCytwq41PlyRRP6qS1/VSPluD28awJvmIWvuUMyV5ctauTYgD4MtE75uWV1JiMW7RbtrWrkK72irAcK5qhAfx0S0dSMsq4NZxy8nK844Ro42pmYyasPy3dXdvj2jHl3d1oVVcFadDOyfdG0by+rC2JCYdZuSE5WRX8P6Gy3ZlsHLPEe7oWc/reps65aKGUdSPquT1zdHnbD7I+r2Z3HdJA/z1t3NWHurdkLqRlXjy67XkFlS89571e4+yOvkI13equBW7B7aOxRiYuvrPBfbFlfQOJWctrmoIPRpG8WViMsUl3vUhPnvzQZLSczWKdwFa16rCuze0Y8v+LO76dAX5RZ45YlRSYjF70wGuG7OYK0fPZ8nODJ7o24RZj1xEv1Y1PfZDul+rmvxnaGuW7srghrFLOZJbcYpk/Nm7v+4golIA1yZUnAIIrubjYxjZvR7r9h5l3jbvHLGxLIvXZ22jVrVgrmob63Q4HiPI35cXr25JcsYxXvtpq9PhlLuJS5MI8vdhSPs4p0NxTI3wIDrXjeDbVXu9+iKQu1GSJ+fkug61SD2ax69bvav3zYcLdhITHkTf5jWcDsWj9WpcnZeGtGLh9nQe+GyVxzXj3p2Ww+B3FjJyQiJ70nP525VNWPjEJdzdq77brrs7F1e3i+Pd69uxMTWTa99fXCGrbm5MzeSXLYe4rXtdr3hN3ck17eOIqxrMKzM3e+WJ3OxNB1m39yj3XaxRvHPVqV4EIzrV5qOFu1hTQXrugl2o69tVqQxsHUN4sPtP73elwW1j2J2ey5qUo06HUmHoXUrOSe+m0URXDuSjBbudDqXMbEg9ypKdGdzcNV5Tt8rAkPZxPNO/md2K4v3FJKV7RiIxc8N++r+5gKT0XP4ztDW/Pn4xd/Ss7xHr7s7FZc1rMP7WDhzIzKff6Pl8uiTJ60bmT+fdX3cQGuin9VQuEODnw8O9G7F+byY/rveu5sclJRav/Wyvxbu6XcUdkbkQT17RhKiwQJ6YsrZCFOgB+HbVXo4VFnN9J73f9G1RkwBfH75dpSmb5UVntHJOAvx8uKVrXRZsT2NDqndcjflowW5CAny5rkPFq3rlKrd1r8v7N7RnZ1oOfV+fzydLktz6yv78bYe4d+JK6lcP5fsHezCkfZxXX6nv2iCSHx7sQau4Kjz97XoGvLmAxTvSnQ7L5ZLSc5ixNpXrO9eu8FfVXWVw21gaVA/l1Z+2eNXFg5kb9rNxXyYPXtrQq98bXKlykD/PD27J5v1ZvP/rDqfDcTnLspi4ZA8tY8NpXauK0+E47njP5elrUykqrhhJvtP0TiXnbESn2lQK8OWDeZ7f0vBgVh7frUnlmvZxXjdi47TLmtfgp4d7khBflb9/u54bP1zGiqTDbpfsbdqXyd2frqRB9VA+HdmxwrTPiKkSzKTbO/HWiLYcyS1g+AdLuOmjZV5z8eZkxszbiZ+vDyO7ae2tq/j6GB7t04gdh3L4xkuu2BeX2BU160dVYrDW4l2QPs2i6deqJm/O2c72g1lOh+NSK/ccZsuBLEZ00gXk4wa3jSUtu4CFFeCiojtQkifnLDzYn2EdavPd2n2kHjnmdDgX5NMleygsKeFWnfS5RM3wYD6+rSMvXNWCVXsOM+TdRfR+7Ve+WZXiFlXW9h09xq3jlhMa6Me4WzsQFlSxEn1jDP1bxTDnL73425VNWJN8hAFvLuD/vt/kcespz+RgVh5frkjhmvZxVK9csZoRl7e+LWrQMjac//y0xStadkxfm8rWA9k81LsRvuqpeMH+MaA5wQG+PDFlHSVeNNr7ZxOX7iE00I+BrWOcDsVtXNwkispBfkz1kgtA7k5JnpyX27rHAzBu4S5nA7kAeYXFTFySxKVNqlM3spLT4XgtYwzXd6rD4r9dyivXtMLHGB6evIZ2z/3M3Z+u4Ls1qeQ4UNI/M6+QW8fZ7QTG3dqBmuEVYwTvZIL8fbmjZ33mPX4x13WszZh5O7nxQ++qwPnRgt0UFZdwR496Tofi9Ywx/L1/M/YdzeP9eZ49La+ouIQ3Zm2jSY0w+rVUT8WyEBUWyDP9m7Ei6TCfLElyOhyXOJpbyIy1+xjUJoZKgX5Oh+M2Av18ubJlTWZu2O8WF3q9nZI8OS9xVUPo17Imny1LJtNDe6JNXb2X9JwCblPbhHJROcifoQm1mPlQTybd3omh7WuxfPdh7v9sFe2e+5lHv1hDckZuucSSW1DEHR8nsv1gNu/e0I6mNSuXy3HdXXiwP/93VUveGtGWNclHGf7BUq/oeZiZV8jEJUlc2bIm8bqgUy461q1Gv5Y1ee/XHR494+Pb1ansTMvhod6N8NEoXpm5ul0sPRpG8vKPm9nrwX8fpzJlZQr5RSUquHISg9rEklNQzM8bDzgditdTkifn7Y6e9cjOL+KzpXucDuWcWZbFRwt206RGGF3qRTgdToXi42PoWj+S5wa3YOnfLmXyHZ0ZmhDHd2tT6fnKXK4fu4TRs7cxd8tB0rPzy/z4uQVF3DZ+Oct2ZfDq0Nb0aBhV5sfwdP1bxTDmpvZsO5DF3Z+upNDDF8l/sjiJrPwi7u5V3+lQKpQnr2iCZcGLP2x2OpTzUlhcwujZ22gRW5nLm0c7HY5XMcbwf1e1xAKenLLWq6ZtWpbFpGV7aFOrCs1idAHxzzrVrUbN8CCmrk51OhSvpyRPzluL2HC61o9g3MLdHlcOeeH2dLYcyGJk97oe29zaG/j6GDrVi+D5wS2Z99jF3H9JQw5k5vPaz1u5ddxy2j8/i+4vzeG+SSt57actTFyaxMLtaexOyyH7PKZ47jyUzfAxS1i2K4P/DmujIgqn0atxdf59dUsWbE/j/77f5HQ45y0zr5CPFuziokZRNI8JdzqcCqVWtRDu6FmPaWtSWZGU4XQ45+zjxUnsycjl0T6N9TnhArWqhfBUv6bM35bGu15UbXP57sNsP5itgiun4ONjGNg6hnlbD5GR4z1LAtyRJgrLBbm9Zz1uHbec79akMqS95/QO+nDBTiJDAxjYRgui3UWN8CAe6dOIR/o0IiuvkA2pmaxNOcLq5COs2nOEGev28efCnJUCfIkMC8Sn9AQs0M+HqLBAAnx9MMbgY8DHGIyBjJwCVu05QnCAL+/e0J7L1fj+jIYm1GLTviw+WriLlrHhHtkf7O2528nILeAvlzV2OpQK6e5e9fkyMYV/freRr+/u6jG9SA9m5fH6z1u5qFEUvRprtN9VRnSszdKdGfznpy00jg6jdzPPHzGdtDSJsCA/BrTS+cWpDGoTy/vzdjJjbSo3dol3OhyvpSRPLkivRlE0jg7jg/k7ubpdrEdc7dx+MIu5Ww7xUO+GBPr5Oh2OnERYkD+d60XQ+YSptEXFJRzMyicpPZe9R46Rlp3Pwcx80rLzsQAD5OQXkZadT7FlUVICJZaFZdlfw4P9Gd6xFnf3akCNcFVXPFt/vbIJG/cd5a9fr6NRdBgtYj1nNGz7wWzGLdjN1W3jaBnnOXF7k5AAP57q15T7P1vFO7/s4IFLGzod0ll56Yct5BUV8+yAZh7xueapjDG8OKQlu9NzuP+zVXx2R2faeHBPuYycAr5ft5/hHWsRHKDzi1NpWjOMRtGhfLtaSZ4rKcmTC2KMYVSPujz21Vrmb0ujZyP3v+L59twdBPv7cmNnLYj2JH6+PsRUCSamgvSxcxf+vj68PaIdA95cwJ2frGDafd2ICA10OqwzOlZQzD0TVxAa5McTfTWK56QBrWOYvekAb8zeRrcGkbSvU9XpkE5rRVIGU1amcE+v+tSLCnU6HK8XEuDHhzd34Op3FzJy/HK+vqcrdSI8s0DSlBUpFBSXMEIFV07LGMOgNrG8MnMLyRm51KoW4nRIXsll8yaMMdWMMT8bY7aVfv2fd3VjTBtjzGJjzAZjzFpjzDBXxSOuM6hNLNGVA3lrzna3a3T9Z7vScpi6ei83dqnjESeqIu4gIjSQ929M4FB2PvdNWkWRBxRi+fvU9Ww7mM3rw9qoL54b+NfgFtQMD+KhyavcumJrcYnF37/dQM3wIO67pIHT4VQYUWGBjL+1I8WWxW3jl7v138ipWJbFZ8v20L5OVRrXCHM6HLc3qHS5zNTV6pnnKq6cHP8kMNuyrIbA7NKf/ywXuMmyrOZAX+B1Y0wVF8YkLhDg58N9lzRk2e4MZm066HQ4p/Xaz1sJ8PPhdvXKEjknLePC+b+rWrJ4Zzqv/rTV6XBO64vEZL5akcL9FzfwiNkFFUHlIH/euK4NqUfyeGbqBqfDOaVJy/awcV8mT/VrSkiAJjuVp/pRobx7fXt2p+fyly/XuP1F4z+bvy2NnWk5jOiogitnI65qCB3jq/HNqr0e91p7ClcmeYOACaXfTwAG/3kDy7K2Wpa1rfT7VOAgoE9kD3Rdh1rUi6rEv3/Y5LaVNlckHea7Nanc0aMeUWEaxRM5V9e0j2NEp9q89+sOZqzd53Q4J7VpXyZ//3Y9XetH8GDvRk6HIydoX6caD1zSkG9W7XXLq/cZOQW8OnMLXepFqPG5Q7rUj+CvVzRh5oYDHldx871fdxBdOZD+rfW3c7YGtY1hx6EcNqRmOh2KV3JlkhdtWdbxs4D9wGlLJhljOgIBwEn/Vxtj7jDGJBpjEg8dOlS2kcoF8/f14el+Tdl5KIcx89zvjbmkxOK56RupHhbInRepV5bI+XqmfzPa16nKw1+sZtku9yqLn51fxL0TV1I52J83rmuLr5pXu517L65PQp2qPP3NepIzcp0O5w9embmZnPwi/jmouYqtOGhk97oMaB3DqzO3sGBbmtPhnJXVyUdYtCOdUd3rqaDbOejXsib+voZvV7nfRR9vcEFJnjFmljFm/Ulug07czrLHYU85FmuMqQl8AtxqWdZJh4EsyxpjWVaCZVkJUVEa7HNHlzSJpl/Lmoyes52dh7KdDucPvlubyurkIzx2eWMqBWoKjsj5CvL35YObEoirEsyNHy5l+lr3aGhrWRZ//Xodu9NzeHN4W43Wuyk/Xx/+O6wNAA9+7j7rO9ckH+Hz5cnc0jWeRtFaT+UkYwwvDWlJg+qhPDR5FQcz85wO6Yze/WW7XcFZvfHOSZWQAC5qVJ1pa1IpLtGUzbJ2QUmeZVm9LctqcZLbVOBAafJ2PIk76WItY0xlYAbwlGVZSy4kHnHeswOaEejnw9++Wec2c6yPFRTz0g+baRFbmSEe2OdLxN1UqxTAl3d1oWVsOPdNWsXdn65g/d6jjv6fn7RsD9+tSeXRyxr/ofWGuJ9a1UJ44eqWrNxzhDfnbHc6HEpKLJ6ZtoGISoE82NszWjx4u5AAP94e0Y6c/GIemrzarROArQey+GnjAW7uUodQXUQ+Z4PbxnAwK5+F2z1j1NaTuHK65jTg5tLvbwam/nkDY0wA8A3wsWVZX7kwFikn1SsH8dcrmrJkZwZfJqY4HQ4AH8zfSerRPP7erxk+mr4lUiYiQgOZdHtnHru8MXO3HKT/mwsY8cFSth7IKvdYNqZm8s/vNtKzURR3azq2RxjYOoar28Xy5pxtLN/t7LTfT5cmsSb5CH+7sglhQf6OxiK/axgdxr8GNWfRjnTecoOLAafy2k9bqRTgxy3d6jodikfq3TSaqiH+fL58j9OheB1XJnkvAn2MMduA3qU/Y4xJMMaMLd3mWqAncIsxZnXprY0LY5JycF2HWnSMr8YL329yfJrFgcw83v1lB1e0qEEnXd0XKVMBfj7ce3EDlv61N8/0b8bGfZlc+cZ8Xv5xM/lFxeUSQ05+EfdNWknVEH9eu7a1LuR4kH8NakGtaiHcM3Ele48ccySG5IxcXvxhMz0bRXFV21hHYpBTu6Z9HFe3jeWN2VtZvCPd6XD+x9qUI/y4YT8ju9elWqUAp8PxSEH+vgxpF8dPGw5wKCvf6XC8isuSPMuy0i3LutSyrIal0zozSu9PtCxrVOn3n1qW5W9ZVpsTbqtdFZOUDx8fw/9d3ZL8omLunbTS0Wqbr8zcQnGJxV+vaOpYDCLeLjzEn9u612XuX3oxuG0s7/yyg4FvLmRN8hGXHteyLP7+7Xp2p+fwxnVtiVTvS48SGujH2JsSyCsoZuT45eTkF5Xr8Y+v4zTAv69uqWIrbsgYw3ODWxAfWYkHP19FWrb7JAGWZRd0qxriz6geGsW7EMM71aaoxOLLFclOh+JVXDmSJxVYg+qhvDSkFct3H+b5GRsdiWHlnsNMWZnCrd3iqR0R4kgMIhVJtUoBvDq0NeNu6cCRYwUMfmchf/16LQezXDOi/8bsbXy9ai8PXNpQ6/A8VMPoMN66vh1bD2TxyBerKSnHtVeTlyezYHsaf72yKbFVgsvtuHJuKgXa6/OOHivk4cnl+zdyOlNXp7J892Ee76tpvheqflQonepW4/NlyW7z+noD4y7FMc5FQkKClZiY6HQYchZemLGRD+bv4uVrWnFtQq1yO25BUQn935xPVl4RPz3cU2/AIuUsK6+QN2ZtY9yi3RigXZ2qBPv7UmJZ5OQXERLgR1iQH/WjQrk2odY5XYgpLC7hpR82M3bBLq5pH8fLQ1ppmqaHGzt/J8/P2MRVbWN5aUgrAvxcew16XcpRhr6/iLa1qjJxVCf9/XiASUv38Ldv1vF438bc06uBo7EcyMzjyjfmE1c1mG/u6aa/nzIwdfVeHvx8NZ+O7ET3hpFOh+MxjDErLMtKONljKgMkLvVE3yZs3JfJ09+sp1F0GG1qVSmX4777yw62Hsjmo1sSlOCJOCAsyJ+n+zfj+s51mLgkidXJRzhyrBADVAr0JbegiAOZefy08QBvzd1Oz0ZRDGwdw0WNok7Z/mBXWg7TVqcydfVedqblcHOXOjwzoLlOsLzAyO51ySss5tWftnIoK593b2jnsvfufUePMXLCciIqBTJ6eFv9/XiI4R1rsWhHGv/5aSsd4qvRIb6aI3EUl1g8+PkqcguK+c+1bfT3U0Yub16DqiH+TFqWpCSvjGgkT1zucE4BA95aQFGxxbT7u1E9LMilx9t2IIsrR8/nihY1GT28rUuPJSIXZv/RPD5fvofJy5PZd9Se1tkitjI9GkbRsW41alQOYtmuDKatSWVF0mGMgY7x1bite10ub17D4eilrH2ZmMyTX6+jcXQY42/tQPXKZft5kZNfxND3FrMnI5cpd3elcQ31xPMkWXmFDHhzAflFJXz/QA+qOlDs5L8/b+WN2dt4dWhrrmmvtkxl6YUZGxm3cDcLnriEGuGuPVf0FqcbyVOSJ+ViY2omV7+7kGY1K/PxyE4u6yVzrKCYYWPsD/BZj1ykQgwiHsKyLDakZvLr1kPM3XyQ1clHKDphbUaD6qEMbR/H4LaxRJfxib+4l1+2HOSeiSupGhLAh7ck0KRG5TLZ7/6jedz+cSIbUo/y0S0d6NW4epnsV8rX+r1HufqdRfRoGMnYmxPKtWDOTxv2c8cnK7i6XSyvXdum3I5bUexJz+WiV+dy38UNePSyxk6H4xGU5Ilb+GHdPu77bBWt4sIZf2tHwoPLdipOSYnFvZNW8uOG/bx/Q3su01V+EY+VW1DE6j1HSMspoGVsOHUjKzkdkpSjtSlHGDkhkZz8Ip4b1IKr28Ve0Mn8muQj3P6xvb/Rw9tyadPoMoxWytuERbt5dtoGnrqyKbf3rFcux9y0L5Nr3l1Eg+qhTL6zC0H+vuVy3Ipm1IREVu05zMInL9G/8Vk4XZKn6ppSbq5oWZO3R7Rj/d6jDB+zhANl3EPv5Zlb+GH9fp66sqkSPBEPFxLgR9cGkQxsHaMErwJqFVeF6fd3p1nNyjz65Rpu+HApS3emcz4Xpr9bk8q17y8mwM+HKfd0VYLnBW7qUoe+zWvw0o+bWbXnsMuPdzArj5HjlxMa5Mf7NyYo+XChW7vFk55TwPS1+5wOxeMpyZNy1bdFDcbe3IGk9BwGv72QjamZZbLf8Qt38d6vO7ihc21Gdle/GhERTxddOYjJd3bhnwObs3lfFsPGLKHf6AVMXJpE9ln01CsqLuHlHzdz/2eraBkbzrf3diuzqZ/iLGMML13TihrhQdw3aRVHcwtddqy8wmJu/3gFh3ML+fDmDlor5mJd60fQsHoo4xbuOq+LOvI7JXlS7i5qFMWXd3XFsmDoe4v4cf35X60pKbF4e+52/vHdRi5rFs0/BjRXQ1sRES/h62O4uWs8C564hBeuaoEFPPXNeto99zOjJizni8Rk0v/UIDuvsJjv1+1j8DsLeeeXHQzvWIuJt3fSGm0vEx7sz1sj2nEgM4/Hp6xxSUJgWRaPf7WWtSlHeOO6NrSIDS/zY8gfGWO4pVs8G1IzSUxy/SitN9OaPHHM8UXw6/YeZVCbGP4xoPk5VcpKzsjlsa/WsGRnBgNax/Data3x99V1CxERb2VZFquSj/DdmlRmrt9PamlF1vBgf2KrBGMM7DiUTV5hCbWrhfCXyxszsHWMw1GLKx3vsfiPAc24pVvZzuT5Ynkyj09Zy2OXN+bei53tzVeR5BYU0fXFObSMDeeTkZ2cDsetqfCKuK3C4hLembuDN+dso0pIAA/3aci1CbVOmawVFZewbFcG09ft46vEFPx9Dc8OaM7QhDiN4ImIVCCWZbF+byYLd6SRcjiXvYePYQH1IkPp1TiKrvUj8NOFP69nWRajJiQyf1saU+7uSsu4shlt23Eom/6jF9C2dhU+HdlJ/fDK2YcLdvHc9I1MuK0jFzWKcjSWlMO5pReR3O9vQEmeuL0NqUf5+7frWbnnCLWrhXBHz3rUjwrF39fg7+vDoax8Fu1IZ9qaVNKy8wnw82FIu1juv6QhMVWCnQ5fREREHHI4p4B+o+fj5+vD9Ae6Uznowqp35xcVc/U7i0g9cowfHuypdXgOKCgqofdrvxIS4MuMB3rg61CSfTingN6v/crgtrH8vX8zR2I4ndMlea5pViZyjprHhDPl7q7M3XKQV2du5elv1//PNgG+PlzSpDqD2sTQs1EUlVzUa09EREQ8R9VKAYwe3pZhY5bw16/X8dbwthc06vLSD1vYkJrJ2JsSlOA5JMDPhyf6NuHeSSv5fPkeru9Ux5E4/u/7TRw5VsiQdp7X+F5nyeI2jDFc0iSaixtXZ+uBbNJz8ikqtigqKSE82J9mNcMJDlDZYhEREfmjhPhqPHpZI17+cQtd6kVwQ+fzSwo+Wbybjxbu4pau8fRupnYbTrqyZQ261Ivg/2ZsonuDSOpElG87nUXb0/hyRQp396pPsxjPq8yryeridowxNK4RRtf6kfRsFMUlTaJpX6eaEjwRERE5pbt61ueiRlH887sNLNiWdk7PtSyLMfN28PepG+jdtDpP9WvqoijlbBlj+M+1rfHxMTzw2SqOFRSX27FzC4r42zfrqBMRwoOXNiy345YlJXkiIiIi4vF8fAyjh7elflQod36SyOId6Wf1vOz8Iu6btIr/+34zV7SowVsj2qlat5uIqRLMq0Nbs3bvUR6avIrikvKpJfL8jE0kZeTy0pBWBPl75iCDy/6CjTHVjDE/G2O2lX6tepptKxtjUowxb7kqHhERERHxbuHB/ky4rSMxVYK5+aNlTFuTetrttx/MZvDbC/lh/T7+ekUT3rm+ncee1Hury5vX4O/9mjFzwwGen7HR5cebvekAk5bu4Y6e9ehcL8Llx3MVV16meBKYbVlWQ2B26c+n8hwwz4WxiIiIiEgFEF05iK/u6kqbWlV44LNV3PjhUuZuPkjJCaNAlmUxZUUKg99eyOGcAj4d2Yk7L6rvlmXyBW7rXpfbutVl3MLdvDJz8x9ey7J0KCufx79aS9OalXmkTyOXHKO8uLLwyiCgV+n3E4BfgCf+vJExpj0QDfwInLQEqIiIiIjI2QoP8efjkR35cMEuPl68m1vHLye6ciAtY8OpVimAHYdyWJF0mIQ6VRk9vK3aMXmAp/o1JbegiLfn7mDbgWz+O6xNmVZatyyLJ6esJSu/iM+ua0Ogn2eP6LqsT54x5ohlWVVKvzfA4eM/n7CNDzAHuAHoDSRYlnXfKfZ3B3AHQO3atdsnJSW5JG4RERER8R4FRSX8sH4fszYdZMv+TI4eKySiUiDDOtTihs51HOvBJufOsizGLdzN8zM20rpWFcbf0pHwkAvri3jcxKVJPPXNep4d0Ixbu9Utk326msuaoRtjZgE1TvLQU8CEE5M6Y8xhy7L+sC7PGHMfEGJZ1svGmFs4TZJ3IjVDFxERERGpmGZu2M/9k1ZRv3oon4zsSGRo4AXtb+ehbPqNXkBCfFUm3NoRHw9J/F3WDN2yrN6nOegBY0xNy7L2GWNqAgdPslkXoIcx5h4gFAgwxmRblnW69XsiIiIiIlJBXd68BmNvTuCOTxK59r3FfDqq03lPuc0tKOKeiSsJ9Pfh1aGtPSbBOxNXFl6ZBtxc+v3NwNQ/b2BZ1vWWZdW2LCse+AvwsRI8ERERERE5nZ6NovhkZCcOZeUz9L3FJKXnnPM+CopKeHjyarYeyGL0dW2Jrhzkgkid4cok70WgjzFmG/Z6uxcBjDEJxpixLjyuiIiIiIh4uQ7x1Zh0e2dyC4oY8u5ift544Kyfm5lXyK3jlzFzwwGe7teMno2iXBhp+XNZ4RVX0po8EREREREB2HYgi/s/W8Xm/Vn0a1WTp/s1pWb4yadvFhaX8P26fbz281b2Hj7Gi0NacU37uHKOuGy4rPCKU5TkiYiIiIjIcQVFJbz36w7emrsdHwN3XVSfO3vWJzjAl/yiYpbszGD2pgN8v24/adn5NKkRxrMDmtOlvuc2PFeSJyIiIiIiXi85I5cXf9zMjLX7qBriT0yVYHYcyiavsIQgfx96NoxiWIdaXNy4uscXWXFZdU0RERERERF3UataCG+PaMetXTOYuHQP6TkFdKobQfeGEXStH0mQv2c3OT9bSvJERERERMSrJMRXIyG+mtNhOMaV1TVFRERERESknCnJExERERER8SJK8kRERERERLyIkjwREREREREv4pEtFIwxh4Akp+M4iUggzekg5Iz0Ork/vUaeQa+TZ9Dr5P70GnkGvU6eoSK9TnUsy4o62QMemeS5K2NM4ql6VYj70Ovk/vQaeQa9Tp5Br5P702vkGfQ6eQa9TjZN1xQREREREfEiSvJERERERES8iJK8sjXG6QDkrOh1cn96jTyDXifPoNfJ/ek18gx6nTyDXie0Jk9ERERERMSraCRPRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIkjwREREREREvoiRPRERERETEiyjJExERERER8SJK8kRERERERLyIn9MBnI/IyEgrPj7e6TBEREREREQcsWLFijTLsqJO9phHJnnx8fEkJiY6HYaIiIiIiIgjjDFJp3pM0zVFRERERES8iJI8ERERERERL6IkT0RERERExIt45Jo8OQs5abB5OhxNgarx0KQ/BFdxOioRERER8RKFhYWkpKSQl5fndCheLSgoiLi4OPz9/c/6OUryvI1lwYrxMPNvUJj7+/0zn4KBo6HZIMdCExERERHvkZKSQlhYGPHx8RhjnA7HK1mWRXp6OikpKdStW/esn6fpmt7EsmDGIzD9IajVCe5aCM8chlFzIKIBfHEzrP/a6ShFRERExAvk5eURERGhBM+FjDFERESc82ipkjxv8tPTkPgRdHsQbvgaarQAHx+Iaw83fwe1O8PXd0CK2k+IiIiIyIVTgud65/NvrCTPW6z9Eha/BR1uh97/tJO7EwWEwPDPITQavr0HCjV3WkRERETEGynJ8wYZO+G7B6F2F+j7bzhVth9cBQa+AWlbYMFr5RqiiIiIiIgrvPDCCzRv3pxWrVrRpk0bli5dyqhRo9i4ceN57e/AgQP079+f1q1b06xZM6688soyjtj1VHjF01kWfPcQ+PjCkA/B9wxVdxr0hmaDYVHpqF9oVHlEKSIiIiJS5hYvXsz06dNZuXIlgYGBpKWlUVBQwNixY897n8888wx9+vThwQcfBGDt2rVlFW650Uiep1vzGez6FXo/C+GxZ/ecS56GomMazRMRERERj7Zv3z4iIyMJDAwEIDIykpiYGHr16kViol2HIjQ0lKeeeorWrVvTuXNnDhw4AMChQ4cYMmQIHTp0oEOHDixcuPC3fcbFxf12jFatWgFw7733Mm3aNACuuuoqbrvtNgA++ugjnnrqKQA+/fRTOnbsSJs2bbjzzjspLi4G4KeffqJLly60a9eOoUOHkp2dDUB8fDyPP/44LVu2pGPHjmzfvr1M/l00kufJcjPsVgm1OkP7287+eZENofVwSBwHPR+DkGqui1FEREREvN8PT8L+dWW7zxot4YoXT7vJZZddxr/+9S8aNWpE7969GTZsGBdddNEftsnJyaFz58688MILPP7443zwwQc8/fTTPPjggzz88MN0796dPXv2cPnll7Np0ybuvfdehg0bxltvvUXv3r259dZbiYmJoUePHsyfP5+BAweyd+9e9u3bB8D8+fO57rrr2LRpE5MnT2bhwoX4+/tzzz33MHHiRK688kqef/55Zs2aRaVKlXjppZd47bXXeOaZZwAIDw9n3bp1fPzxxzz00ENMnz79gv/plOR5sl9fhryj0P+//1to5Uy63AerJ9o99Xo84pLwRERERERcKTQ0lBUrVjB//nzmzp3LsGHDePHFPyaGAQEB9O/fH4D27dvz888/AzBr1qw/rNvLzMwkOzubyy+/nJ07d/Ljjz/yww8/0LZtW9avX0+PHj14/fXX2bhxI82aNePw4cPs27ePxYsXM3r0aCZMmMCKFSvo0KEDAMeOHaN69eosWbKEjRs30q1bNwAKCgro0qXLb8cdPnz4b18ffvjhMvl3UZLnqdJ3wPKx0PZGiG527s+PbgZ1L7L30fX+M6/lExERERE5lTOMuLmSr68vvXr1olevXrRs2ZIJEyb84XF/f//f2hD4+vpSVFQEQElJCUuWLCEoKOh/9lmtWjVGjBjBiBEj6N+/P/PmzWPIkCEcOXKEH3/8kZ49e5KRkcEXX3xBaGgoYWFhWJbFzTffzL///e8/7Ou7776jT58+fPbZZyeN/8QWCWXVkkJr8jzV7H+CbwBc/Lfz30enuyBzL2ydWXZxiYiIiIiUky1btrBt27bffl69ejV16tQ5q+dedtllvPnmm394LsCcOXPIzc0FICsrix07dlC7dm0AOnfuzOuvv07Pnj3p0aMHr776Kj169ADg0ksv5auvvuLgwYMAZGRkkJSUROfOnVm4cOFv6+1ycnLYunXrb8edPHnyb19PHOG7EEryPNHelbBxqj0CF1bj/PfT8DKoVN0u3iIiIiIi4mGys7O5+eabadasGa1atWLjxo384x//OKvnjh49msTERFq1akWzZs147733AFixYgUJCQm0atWKLl26MGrUqN+mYPbo0YOioiIaNGhAu3btyMjI+C3Ja9asGc8//zyXXXYZrVq1ok+fPuzbt4+oqCjGjx/P8OHDf9vn5s2bf4vj8OHDtGrVijfeeIP//ve/ZfLvYizLKpMdlaeEhATreLWcCmnSMEheCg+uhaDKF7avmU/B0vfh0S1QKaJs4hMRERERr7dp0yaaNm3qdBgeLT4+nsTERCIjI0+73cn+rY0xKyzLSjjZ9hrJ8zR7V8LWH6HLvRee4IFdZbOkENZ/deH7EhERERERxynJ8zS/vgxBVaDjnWWzvxot7PK0qyeVzf5EREREROSs7N69+4yjeOdDSZ4nSV0FW3+w2x+UxSjeca1HwL7VcHDzGTcVERERETnOE5d+eZrz+TdWkudJfnnJHsXrdEfZ7rf5VYCxi7mIiIiIiJyFoKAg0tPTlei5kGVZpKenn7TNw+moT56nSF1tj+Jd/DQEhZftvivXhNqd7SSv1xNlu28RERER8UpxcXGkpKRw6NAhp0PxakFBQcTFxZ3Tc5TkeYpfX7KTu7IexTuu2SD48UlI2waRDV1zDBERERHxGv7+/tStW9fpMOQkNF3TE6Suhi3fl67FK+NRvOOaDrC/asqmiIiIiIhHU5LnCX59uXQUr4wqap5MeBzEdYBN01x3DBERERERcTmXJ3nGmL7GmC3GmO3GmCdP8vgtxphDxpjVpbdRro7Jo+xbC1tmQOd7XDeKd1yzQbBvDWTscu1xRERERETEZVya5BljfIG3gSuAZsBwY0yzk2w62bKsNqW3sa6MyePMewUCK0Onu1x/rONTNjdPd/2xRERERETEJVw9ktcR2G5Z1k7LsgqAz4FBLj6m9ziw0Z4+2ekuCK7i+uNVjYfolrBJSZ6IiIiIiKdydZIXCySf8HNK6X1/NsQYs9YY85UxptbJdmSMucMYk2iMSawwZVrnvwoBodD57vI7ZtP+kLwUsg+W3zFFRERERKTMuEPhle+AeMuyWgE/AxNOtpFlWWMsy0qwLCshKiqqXAN0xKGtsP5r6Hg7hFQrv+M2HQBYsHlG+R1TRERERETKjKv75O0FThyZiyu97zeWZaWf8ONY4GUXx+QZ5r8K/sF224TyVL0ZVK1rr8tLuLV8jy0nV5AD22fD0WQwvva02mr17K9+AU5HJyIiIiJuxtVJ3nKgoTGmLnZydx0w4sQNjDE1LcvaV/rjQGCTi2Nyf+k7YN2X0OVeqBRZvsc2xp6yueQ9yDvq+oqecmrFRbDkbbuFRkH2/z5+POGLaGA3sG82CGp1LPcwRURERMS9uDTJsyyryBhzHzAT8AU+sixrgzHmX0CiZVnTgAeMMQOBIiADuMWVMXmE+f8B3wDo+oAzx28yABa9Cdt+hpbXOBNDRXfsMEy+EXbPh0ZX2Al/jZZQXAiHd0PGDkjbBunb7duuX2HxW9CgNwx+F0KrO/0biIiIiIhDjGVZTsdwzhISEqzExESnw3CNjF3wZnu78XnffzsTQ0kJvNYEaneBa0+6RFJc6XASTBwKGTth4GhoPdweYT2d/GxYMQ7mPG+Pvt74DUQ3L594RURERKTcGWNWWJaVcLLH3KHwipxowWvg4+fcKB6Ajw80vhK2z4LCPOfiqIj2roCxl0L2frjpW2gz4swJHkBgKHS9H26fA8YHxveH/etcHq6IiIiIuB8lee4kYxesngTtboLKNZ2NpWl/ex3Yzl+cjaMi2TwDxvWzC+6M/Bniu5/7PqKbwy0zwD/ETvRSV5V9nCIiIiLi1pTkuZNf/g0+/tDjUacjgfieEBgOm75zOpKKYekY+Px6qN4URs2GqMbnv6+I+nDrDAiqDBMGQfLysotTRERERNyekjx3cWADrP0COt3h/Cge2KX5G10GW763qzyKa1gWzHkBfngMGl8Bt0wvm6IpVePhlu+hUgR8Mhh2L7zwfYqIiIiIR1CS5y7mPA+BlaHbQ05H8rsm/eFYBuxZ7HQk3smyYObfYN7L0PYGuPYTCKhUdvuvUstO9CrHwKdDYOtPZbdvEREREXFbSvLcwZ6l9ohZtwcgpJrT0fyuQW/wDbQbo0vZW/IuLHkHOt0FA98CXxd0NKlcE279AaIawefDYcM3ZX8MEREREXErSvKcZlkw+19QqTp0vtvpaP4oMBTqX2IXBPHAVhtubfdC+Okpe7T08n+fXQXN81UpEm7+DmITYMrtsPNX1x1LRERERBynJM9pO2ZD0gLo+VjZTtUrK00HwNFk2Lfa6Ui8R342fHs3VKkNV71vt6xwtaBwGDEZIhrA5BvsSq4iIiIi4pWU5DmppARm/dM+2W9/i9PRnFzjK8D4wiZN2Swzv/wbjuyBwe/ao6XlJbiKnehhYMpIKC4sv2OLiIiISLlRkuekjd/C/rVw8VN2NUt3FFIN6nTVuryykr4Dlr5vF1qp07X8j1+1DgwcbTddn/dK+R9fRERERFxOSZ5TigvtippRTaHlUKejOb2mA+DQZkjb7nQknu/nZ8AvEC75u3MxNB8MrYbB/P/AvjXOxSEiIiIiLqEkzymrJ0LGDrj0GfDxdTqa02vSz/66WY3RL8juBfaIaPeHISza2Vj6vgghEfDtPVBU4GwsIiIiIlKmlOQ5ofAY/PISxHW017y5u/A4iGmrdXkXoqTE7olXOQ663Ot0NPY03AFvwIH1MP9Vp6MRERERkTLkgsZcckbLx0JWKlw9xrWl88tSk/4w5znITLWba8u5WTPJnhp59VjwD3Y6GlvjK36fttmkH9Rs7XREciqWBYd3QcoKyM8E/xDwDwK/YLsqb1RjCK3udJQiIiLiJpTklbe8o/ZJdf1LoW4Pp6M5e00H2Ene5hnQ8Xano/EseZl2FdVanaDlNU5H80d9X4Sdv9jTNm+f674FgCqakmLYs9i+pSRCynLITT/9cyIa2ol74yuhVkf3nwYuIiIiLqMkr7wteguOHbbX4nmSqMb2SeSm75Tknat5L0POIbt9gbuN3IZUg/6vw+fD7WmbF//N6YgqtqJ8WDYGFr8NWfvs+yIbQ6MrIC7BvlWKsqd8Fx6DomP2haMDG+2em0vehUWjIbgaNOoLXe6BGi2d/Z1ERESk3CnJK0/Zh+yTt2aDIaaN09Gcu6b9YeFoyEmHShFOR+MZ0rbDkveg7fUQ287paE6uyZX2tM15r0LDy+xEQspXcSGsnmS3tTiaDPUutkdZ6/Wy+xueSf1LoOt99qjxjtmw5Ue7yM+aSdD8KvuiUrV6rv4tRERExE2o8Ep5mv8qFOXBJU87Hcn5aXENWMWwforTkXiOmX8DvyC49FmnIzm9K16211pOGQn5WU5HU3FYFqz7Ct5KgO8egNBouPFbuOlbu9XF2SR4JwqqbCd1V78PD62Dno/B1pnwVkf47iE4vLusfwMRERFxQ0ryysuRPZD4kT2iE9nQ6WjOT40W9tSvNZOcjsQzbPsZts2Eix53/6IYwVXg6g/sv9PvH3M6mooh+xBMGGAn1oFhMOILGDUL6l9cNvsPrmJfUHpgFbS7yW7bMrodzHzKnuopIiIiXktJXnn55UXAwEVPOh3JhWk9AlJXwcFNTkfi3ooK4Me/QrX60Okup6M5O3W6QM/HYc1n9uiSuM7eFTDmIrugyoA34I550Ohy16zZDKsB/V+DB9dAuxth8VswphfsX1/2xxIRERG3oCSvPBzcbJ84d7wdwmOdjubCtBwKPn72+iE5tWVjIH0b9P23Z1Ws7PkYxCbAj0/CsSNOR+N9LAuWfQAf9QXjCyN/gva3gE85vBVXjrETyhu+tos/fXCJvUa4pNj1xxYREZFypSSvPMx5DvwrQfdHnI7kwoVG2cU51n4BxUVOR+Oesg/Bry9Bgz726Iwn8fWDfv+BnDSY+39OR+Nd8rPtqZnf/8UuqHLnr870JmxwKdy9yJ4WOvNv8OFlGpkXERHxMkryXC1lhV3lruv93lORsvVwyN5v91eT//XLv6EwFy730CQppg10GAnLP4D965yOxjtk7IIP+8CGb+xKl8Mn2+0rnFIpEoZ/bq/DzNhpj+ptmu5cPCIiIlKm1ELB1Wb/A0Ii7X5V3qLR5RBc1S7k0LC309G4l7TtsGI8JNwGUY2cjub8XfK0nZD88ATcMsP9+vt5kvQdMO5Ku7LuDV+XXWGVC2UMtLoW6vaEz0fA5Bug97PQ7SG93u6o8Bgc2mz/PWUfhGMZkJlqX1DyDbSnhfsGgl+gXeipcqw9RTeysfdcYBQRkbOmJM+VdsyFXfPsfleBYU5HU3b8AqHltbBiHORmODsi4W5m/xP8g+2Kmp4suCpc/BTMeAQ2fQfNBjodkWc6sgc+HgTFBXDrDxDdzOmI/ldYDTuR//YemPUPuyjMoHfsdgzinMx9sGOO/RmybzWkbQWr5IQNjP3aBYRCcb5d7Kk4HwrzoOhP1VMjG0HtzlC7i/21al0l8iIiXk5JnqtYFsz+F1SOs0d1vE27m2DZ+7B2MnS+2+lo3EPKCtg0DXr91f1bJpyNdjfD8rHw09P26K1foNMReZbDSTChP+Rnws3fuWeCd5x/MFzzEcS2h5+fgYMXw9AJdtsUKT8Zu+wiXVu+/32qdEgkxHWApgPt1yOykd1PMajKqQv25GVC5l77tn8d7FkCG6fByo/tx0Oj7WQvvgc0v1ojfSIiXshYluV0DOcsISHBSkxMdDqM09s0HSZfDwPfssuWe6MPLrGnEN29SFeFASbfaF91f3gDBIY6HU3Z2DEHPrkKev8Tuj/kdDSe4/BuGF+a4N34LcS2czqis7d7IXx1G+QdhSFjoWl/pyPybnmZ9sWhNZ/D7vlgfKBWZ2jYBxr0hugWZVN9taQE0rbAnsV20pe0GI7usaslN7wc2gy3v3pSNWARkQrOGLPCsqyEkz6mJM8FSorhve72FK17ltoVC73RivHw3YMwajbEnfTvq+I4sgfeaA1dH4A+/3Q6mrI16TrYvQDuT7Snh8nppW2HjwdCQQ7cNNUuZONpsg7A58Nh70q7DYhG68te1n67Z2HiOCjIhmr17KJWba4vv1Y7+9fbI4drv4Ccg/Y07RbX2AlfTDtdvBMRcXNK8srb2i/g69vt6U8thjgdjevkZ8GrjaHlEBj4ptPROOunv9s9xx5aC+FxTkdTttJ3wDtd7JGFYZ/qxO90Dm6CCQPttVM3TfXs6Y4Fufb72Obp0Okuu1qsj6/TUXm+Axtg0Vuw/isoKbKnS3a6y75Q5tT/reIi2DnX7n+6eYa9ti+yMbS9wZ6aH1zFmbjkzEpKIO+IvT4+N90uyJN31B6h9fEDX3/w8bdHaANCoVKUvZzAP9jpyEWkDCjJK0/FhfBWB/vN9M555dPk2ElT74X138BftnhXcZlzUZADrzWFehfDtROcjsY1FvzXLsrh7RcuLkTWfnsKc0mxvQbPk6urHldSbK/JXPIONOlvt1wICHE6Ks90JBnmvmBPy/QPtkfsutxjj+C5k2NHYOO3sPozSF5i93htM9xeWx7d3OnoKp7iIkjfDgfWw8GNpdVVD9gJXW46HDv8p4I8Zykw3O57WzkWIupDtfoQ2RAiGkDVeF3QEfEQp0vyvHQeoYNWfQqHd9l9sLw9wQO7OMeqT+1y++1ucjoaZ6z53L5y6s1T2rrcbxdu+P4xqHuR3WdNfld4DD6/3j7hum2mdyR4YJ/o9f03VKkDPz5pF5IZ/rl3FBYqL1kHYP5/7GrEGOj2AHR/2J4a6Y6Cq0D7W+zbvrV2gr/yE7sIU/1LoNuD9nuARvTLnmXZCd2eJZC8FPavhYOb7ZFVAONrJ2CVY6B6UwiJsG/B1X7/PqSqXZTHKrGXjBQX2iPGRXmQnw05h+wkMfug3e/2aAqs/9oeDTzOPwSqN7NnIkS3gBot7VtAJQf+UUTkfGkkrywV5sHotvZ0vZE/VYwPQcuCdzrbo3ijZjkdTfmzLHi7k31l/o5fvPs1P7gJ3uthF+IYOt7paNyHZcGUUfb0u2ETvbdQyeYZ8NVIO8G7/ivvSWRdpbgQlrwLv75kXwRoez30fByq1HI6snOXm2GvwV76np0g1Cxdf9xssPeuOS8PlgUZO+0CVzvm2kVxjmXYjwVVgZi2vyda0aWVVV1VGCc3w04w07baU4r3r7NHD48dth83vnaF4LiOUKsj1OpkJ5ze/Jnn7izLnkl0fJruscO/J/UlxfZXq6T055PdV2zvxz/YvvkF2edywdXsiwXB1SAoXK+xm3N0uqYxpi/wBuALjLUs68U/PR4IfAy0B9KBYZZl7T7dPt02yVv8Nsz8mz1Vq25Pp6MpP8d/77sXu3eZeFfYPhs+vRqueh9aX+d0NK437xWY8zxc+4l65x0365+w4DW49Fno8YjT0bjW3hUwaZh9InHdJIjv5nRE7mn7LPjxb3Y1y4aX26OhEfWdjurCFebZbXMWvQnp2+x+e90etN/7tMbr7BTl21WYt86EbT/BkST7/iq17fOGWp3tBCqigfOzgSwLMlPthG/vCkhZZrcKKsiyHw+t8Xv/xTpdSivBappnmSnIsad5Hy29HUm2R16PpkDWPvuCS2Gua2MwvvbofkikfYEvtLr9uleuaY8oV461v4bF6IKPQxxL8owxvsBWoA+QAiwHhluWtfGEbe4BWlmWdZcx5jrgKsuyhp1uv26Z5OVnwRtt7KtuN011OprylZMO/2kMHUbBFS+eeXtvMnEopK6Gh9dXjD5yxYX2urOsfXDvMgip5nREzlr0Fvz0FLS/Ffr/t2Jc8Ty82/67P7zbbpreaqjTEbmPI3vg+8dh6w92AnT5/0GTK52OquyVlNi9/Ob/B1JX2lf8O90Fne5UkZaTKTxmj9ZtnApbfoT8o/aUyLoXQcPe9nruavU84/2jpBgObbanlB5vx3E02X4sIMwe5avTxU78Ytsr+T8bx47AoS32RaFDW+x/30Nbfv93Pc7HrzSxirOTrNAa9rrKkEj7szi4KvgG2om2j9/vX43P74V4/nyfVWJfeCjM/X1K77EMe2T3xK85ab9P9c3a/7/JpfG1YwuvZc9W+O1rHITXtr9qPbdLOJnkdQH+YVnW5aU//xXAsqx/n7DNzNJtFhtj/ID9QJR1msDcMsn79RWY+zyMmgNx7Z2Opvx9eQvs/AUe2Qz+QU5HUz7StsNb7e3m572edDqa8rN/HYzpZRdguXqM09E4Z/3X8NWt0GwQXDOuYl3BPnYYPr8BkhbAJU9Dj794xgmqqxQXwbL3Yc4LgGW/H3S6y/sv/FiW3V5l8dt2YhsYDgm3QMc7vK/K8LkqyIXtP9uJ3daZdpuM4KrQpB80HWSP2nnLZ+WR5NKkb5Hdf/HQJvt+H397ymmdLlC7q50AVuQLgznp9r/NoT8lc9n7f9/GL8ielhvVxJ4SX7WunTCFx9ktjNzhc8ay7DoEman27ejxEcbk30ceM1PBKv7j80IiT0gAa/9vQhhUpWJ/jpwnJ5O8a4C+lmWNKv35RqCTZVn3nbDN+tJtUkp/3lG6Tdqf9nUHcAdA7dq12yclJbks7nNWlA+vNbOnWAyf5HQ0zjjeNHvIh9DyGqejKR/fP2avU3l4Q8UrRDHnBZj3Mtw8Her2cDqa8pe6Cj7qCzXbwM3TvP9k/mSK8mHqfbDuC2hzgz2SWREbaSctghl/gYMb7KmZ/V61T2Aqmn1r7ZG9TdMAY38OdHuoYk3hz8+yE7pN02Dbz/ZoR0ikvU632SCI72G3NPB2uRl24Zg9i+2kL3UVlBTaj1VvVjrFs6v91RPXqJ5JUT6kbbPXsR9YV7rGcf0fk7mAUIhqXJrMlX6NbGS/d7hDInehiosgK/WEKaZ7fk8Aj38tyvvjcwJCTzISeEJCGBrt/BRmN+QVSd6J3HIk73CSPexdra7TkTijpARGt7avOt08zeloXC/vqJ3YNx0AV73ndDTlr/AYvN3RLq9+1/yKceJyXNZ+GHOx/UF8+1x7ukxFZVnwy7/t4iL1esG1H9sL9SuC/Gx7qu6K8fYJSN8X7VGain4l+sgeWPKeXU20MNeettdhlJ3keOP7RN5Rewrmxqn2WszifPtktOkA+3eu3VVrlQqP2Wv6khbbiV/yst/X9YXXspO9mHZQs5VdxdNT3kOKi+zCOYc22QndwY321/Qdv49i+QbYSVx0C7sFSfVmdkJXOaZiv1dYlj0F9Lfk78SRwNL7Tqz4CvbIcHis/TcTXNUuEhMQCoGhduXXgLDS70t//sPjpbfjFyItq7TqbL5dhbYo3/6/W1z4+/dFBaUVaksfr1bPLS9aabqmlI/jU1YfWO39ye7xYjN3/AoxbZyOxhmbZ8DnI+x1R13udTqa8lGYB+P72R/mI3+yT0gEVk2E7x6wG2gPn2RX3fNmO+bC9Ifsi3td77OnbKu8/B/lZtjtdRI/stsKhcVAh9ug7Y32tDNPdnzEbv2U0sSuwP79mg2yC1LV6uQdozGuUlxkj3wfT/r2LPnjKFeVOqUJX2v7a2RD+9/XiemtlmWvQzu8+/db+g47mUvbYr/2ABj7vCeqqd3e4vgtspF3XtwoD/lZJ4z+7fk9ETyaYq9jLMixLxbkZ//v1NBT8Q0ATOnrdo75T7eHoM8/z+055cDJJM8Pu/DKpcBe7MIrIyzL2nDCNvcCLU8ovHK1ZVnXnm6/SvLc1NG98HoL6P4IXPp3p6NxneKi0lYZsXDbj05H4xzLsgtw7FkC9yd6/onbmVgWfHOnXV1w2Kf2lXr53Y658MXNYLCrzTa+wumIyt7RvXa/wE3T7FkLg9+BOl2djsq9lZTYVSSXvAO7frWLPTTqa/dYrX+x55wA56TZxWY2TbfXnxfnQ1hNaH41NL/KLjKiqWTnL+uA3Rdw/1p76u/+tfYo2YlCIv5Y0fEP38fan0G+AXZRkd9uJxktsyx7ZCbvyO9N5XMzfm9FkH3QvoBzeLdd/fQP0wqNfawTE7moJvZNhUWcYVn2a1SQYyeGBdml32f/ngSemBBi2QVq/ALsr74Bv3/vd/znQPu96cT7QqMhLNrp3/Z/ON1C4UrgdewWCh9ZlvWCMeZfQKJlWdOMMUHAJ0BbIAO4zrKsnafcIUry3NrEa+0354fWe+8UleMFN66bZE/PqsjSd9h9Eptf5f1FWBa8DrOehYufhoseczoa95SxC768GfatsUvrX/qsd4xoWBasnmi3RSgugJ6PQpf7vadwRnlJ2w4rx8PqSfYJdUiE/d7R6jr3S5Isy15Lte0ne31d8hJ7SUZ4bXuNXZP+9jRDb/j7dlf5WfZatsO7IHPvCYU+9to/H+8peCYnJn1nM4oTWNkeTaxax56VUDXevqhTtY49VVD/78WNOJrkuYKSPDe2aTpMvh6GT4bGfZ2OpuxZlt1CIO8o3JfoXiclTpn9HMx/FW79wXtHNdZ+AV/fblcUHfJhxV5LcSaFeTDzr/Y0vQa97X8vTy6rn74DZjxij97U6QaD3rLXZsj5KyqwK0+u+xK2/GBfhQ+NhoaXQdOBzlWezNxnv87Hb8enENZoCY2usJO7Gq30/99dFB77PfHLTLVfr+JC+3PaKjn1zS/Qbu0QVMW+0BBSzf4aXM3+viIW0hKPpSRPyk9xoV2QJC4Bhn/mdDRlb/dCGH+lXUkw4Tano3EPBbmlRVhC4I5fvG/KyvZZdgPw2l3ghik6AThbK8bbVSfD42DQ257XOD3vKMx7xS4i4h8Mlz4DCSN1Yaes5WXa0yC3/gjbZ0N+pj1FqlZHiO8OsQl2Gf5KEWV73OJCSNsKe1favf52L7B/BvuEv14vu39dg952TzIRETekJE/K18/PwqI37dYC3vbh+Ok19gnBwxvU5PVEO+bAJ1dDuxth4JtOR1N2DmyED/vYC+pvmeE5Vd/cxZ4l9jrGw7vtBKnPP+2KZ+6spBhWfWKPUOemQ9vr4ZK/e/+aU3dQlA+75tmjaLvm2T05j0+rC69tV7aLaGBPn6tS225dE1zV/n8ZEGo3ZAa7al5hrj3d79hhyDloF2s4kmyv80rbape4L863tw+sbCeVdS+CehdBdEsl8yLiEU6X5HnpoilxVLubYOHrsGYS9HjU6WjKTvJye4rRpc8qwfuz+pdA94dhwWv2iZI39ErMSYfPrrNPHkd8oQTvfNTuDHcvsvsqLnnHrkg44A1o2NvpyE5u90L48Qk7uajdBfpOqbjVc53gFwgN+9g3sEf59q22+6ylrrYbR+/8FYqOnd/+ja89shzV2H7PqtHS7nUZ0UBJnYh4HY3kiWuM62cvjL5/pfd8eH5ylV1Q4sG1dt8V+aPiIru9wIH1dmuJyAZOR3T+igvt1zt5Gdz6vT39WC5M8jK7eXraFmg9Ai5/wV7/4g6O7IGfn4EN30DlOLjsObsgiNZeuZ/jJe2Ppthfjx22p9YW5NrrrbDsYih+wRBU2V53VSnKTu7CanhONU8RkbOgkTwpf+1ugm/ugKSFULeH09FcuD1L7CmJfZ5Tgncqvn5wzUfwXnf44ia4fbbnjnj+8ATsng9XjVGCV1ZqdYS75tvr3Bb8F7bNhIv/Bu1uca4S75E9sPR9WD4WMNDrb9D1fu9bV+pNjLGTNU2fFRE5LS8ZYhG303QA+FeC9V85HUnZmPt/UKk6dBjldCTuLTwWrv7AbnT7vYe2GVg+FhI/tFsAtB7mdDTexS8QLnnaLtAT1RRmPArvdbMLbpTnrJKDm+DrO+GNNrDkXbuJ9f2J0OsJJXgiIuIVlOSJawSE2C0UNk6zp755st0L7Sa+3R/WCeDZaNgbuj9iF6/Y8K3T0ZybLT/ayWmjvvbaS3GNGi3hlukwbKJdPv/Tq+1+i4veguxDrjlmfjas/AQ+vMw+1qZp0OkueGit3eMxPM41xxUREXGA1uSJ6xzvmXfDFLsMtaeaMMBe8P/gGs+dfljeigvtk+mMHXbhDU84gd6zBD4eDNWbwM3TNS23vBTlw5rP7YsCKcvt4hgNL4M2w+1k+0JaVhQXwd5EWPWpvd6uIBsiG0HbG6HN9WVfll9ERKQcaU2eOKNBb7s09fpvPDfJS1psl/K+/P+U4J0LX38YMhbe62FPi7t5ml0MwV3tWwsTr7Wnm474UgleefILhPY327eDm+2qvGsmw9YfIDDcrtBZp6vdIDuivv2ecrKCKCXFcOwIHFgHe5bCnsV20liQbU8db3EVtL3JXhuogioiIuLlNJInrvXNXXaj279s88wm0h8PsnulPbhGUzXPx6pPYeq9diNpd22nkbYdProc/ILgth+hSi2nI5LiIrtX2qZpdrJ2vEk1gI+/XZWzUpTd3uJYBuSk2VUWj/dUw0B0C6jdyW6F0Ohy9+/PJyIico40kifOaX41rPnMrkzZ+Aqnozk3e5baJ5qXPa8E73y1uR62/WwXrqnXC2LbOx3RHx1JthN5gJumKsFzF75+9trO4/30sg5A0gI4utduUH48scvPgupNISQSKkXajbEjGkKtDuprKCIiFZqSPHGter3sPkXrv/a8JO/XF+2Tx4TbnI7EcxkDA16HlESYfCPcNtN9Eqnsg/DJYDtRuGW6Z/f183Zh0dBiiNNRiIiIeAxV1xTX8guw2yls+R4Kjzkdzdnbv94efex6HwRUcjoazxZcFUZ8blc3/HgQZKY6HZE9te+Tq+1Yrv8CarZyOiIRERGRMqMkT1yvxdV28YNtPzsdydlb+i74h0D7W5yOxDvUaAk3fGWPno27wm5C7ZSMXXblz0ObYdindmEPERERES+iJE9cL76nPe1xw9dOR3J2ctJg7ZfQ+jp7FErKRq2O9rq3Y4dh3JWQsbP8Y9izBMZeaiebN30LDS4t/xhEREREXExJnrierx80GwhbZ0JBjtPRnNmKcVCcbzdKlrIV1x5ummaP7I7rZ1e2LC9rv7B7HgZVgVGzIb57+R1bREREpBwpyZPy0WIIFObClh+cjuT0igpg2ViofwlENXY6Gu8U0wZumQHFBXbSlbHLtcezLJj7b/j6dojrCKNmqciKiIiIeDUleVI+aneFsBhY96XTkZzexqmQvR863e10JN4turk9dbPoGEwY6Lqpm4V5MGWUXSm1zfVw4zd2jzURERERL6YkT8qHjw+0HALbZ0FOutPRnNrSdyGiATTo7XQk3q9GC7jxWyjIgjEXw6bp9qhbWcnYCRP6w/qv4NJnYdDbdrVXERERES+nJE/KT8troaQINn7jdCQnl7wc9q6AjnfaSam4XkwbuH0uhMfB5OvtFgvJyy5sn4eTYOZT8G43OLQVrv0Yejxi9+wTERERqQB0Jivlp0ZLiGpiV650R0vfhcDK0Ga405FULNXqwh2/QN+X4MB6+LCP3cPuXJO9g5thyu0wug0seRea9IN7FkOzQa6IWkRERMRt+TkdgFQgxkDLoTDnOXu0pWodpyP63dEUez1exzshMMzpaCoeX3/ofBe0vQESP4SFb9jJXsPLoOv9UKcb+Pj+7/OKCyF5KSx9z57u6R8Mne+Bznfbo4MiIiIiFZCSPClfx5O89V9Bj0edjuZ3S96114N1VtsERwWGQrcHIWEkLBtjJ3sTBoBvoN2z0BiwSqCk2N4+P9Ou0hlUxZ6S2fleqBTh6K8gIiIi4jQleVK+qtaBWp3tnmXd3WSdVN5RWDEBml8FVWo7HY2Anez1eAQ63Qnbfoa9iXDsiP33YnzsG9ijrjVbQ6MrICDE0ZBFRERE3IWSPCl/bUbAdw/AniVQp4vT0dgJXkEWdL3P6UjkzwIqQfPB9k1EREREzooKr0j5a3kNBIbba6+cVphnT9WM7wExbZ2ORkRERETkginJk/IXUAlaX2cXOslJczaWxI8gKxV6PuZsHCIiIiIiZURJnjgj4Ta7YMaqT5yLIT8b5v8H6vaEehc5F4eIiIiISBlSkifOqN4E6nSH5R/ZZfCdMP9VyE2DS55x5vgiIiIiIi6gJE+c0/U+OLoH1jnQHP3QVlj0FrQeAbU6lP/xRURERERcREmeOKdRX4huaU+ZPN73rDwU5cM3d9gl9/v8q/yOKyIiIiJSDpTkiXOMgYseg/TtsHpi+R33x79C6ioY9A6ERpXfcUVEREREyoGSPHFW04F2c/TZ/7Kbkrva2i/s1g1dH4Cm/V1/PBERERGRcuayJM8YU80Y87MxZlvp16qn2K7YGLO69DbNVfGImzIGrnjRbqUw28VTJw9ugu8ehDrd4NJnXXssERERERGHuHIk70lgtmVZDYHZpT+fzDHLstqU3ga6MB5xVzFtofPdsHwsbP3JNcfIz4LJN0JAKFzzEfj6ueY4IiIiIiIOc2WSNwiYUPr9BGCwC48lnu7SZ6F6c/j2LsjYVbb7tiyYdj9k7LATvLAaZbt/ERERERE34sokL9qyrH2l3+8Hok+xXZAxJtEYs8QYM/hUOzPG3FG6XeKhQ4fKOlZxmn8QXPuxXWVz0rX29M2ysvR92PANXPoM1O1RdvsVEREREXFDF5TkGWNmGWPWn+Q26MTtLMuyAOsUu6ljWVYCMAJ43RhT/2QbWZY1xrKsBMuyEqKiVBHRK0U2gOsmwpE9ML4fZO2/8H0mL4OfnoLGV0K3hy58fyIiIiIibu6CkjzLsnpbltXiJLepwAFjTE2A0q8HT7GPvaVfdwK/AG0vJCbxcPHd4fqv4EgyjLsCMnae/75y0uDLWyA8Dga/axd5ERERERHxcq6crjkNuLn0+5uBqX/ewBhT1RgTWPp9JNAN2OjCmMQT1O0BN02FY4dhbG/Ys+Tc91FSDFNG2YnetR9DcJUyD1NERERExB25Msl7EehjjNkG9C79GWNMgjFmbOk2TYFEY8waYC7womVZSvIEanWAUbMhuCpMGGD3tzsXc1+AnXPhylegZmvXxCgiIiIi4oaMvVzOsyQkJFiJiYlOhyHlITcDvrgJds+Hi56EXk+eedrl2i/g69uh/S3Q/3VN0xQRERERr2OMWVFa2+R/uHIkT+TChVSDG76GNjfAry/CV7dCXuapt9+9EKbeB/E94MpXleCJiIiISIWjJE/cn18ADHoLev8TNk6FMb0gddX/brflB/h0CFSpba/D8/Uv91BFRERERJzm53QAImfFGOj+EMR1gCkjYczF0OJquzWCfwis/wrWT4EareyRv5BqTkcsIiIiIuIIJXniWeK7wT2LYcF/IXGcndgB+AVDz8egx6PgH+xsjCIiIiIiDlKSJ54nuCr0+Rdc8gwcWAfFRRDdDAIqOR2ZiIiIiIjjlOSJ5/L1g5i2TkchIiIiIuJWVHhF/r+9u46vsvz/OP66ViyoMUpijO4eKIJ0KyUgICiN0iKhoIiACEgjIUhISSvdjfSAESNHjsGAEeve9ftj0x/6Hbmz3eecfZ6Pxx7snHPHGy7Odj73fYUQQgghhBDCikiRJ4QQQgghhBBWRIo8IYQQQgghhLAiSmttdIbXppR6CNwyOkcSsgKBRocQLyXtZP6kjSyDtJNlkHYyf9JGlkHayTKkpXbKp7XOltQLFlnkmSullJfW2tPoHOLFpJ3Mn7SRZZB2sgzSTuZP2sgySDtZBmmnBNJdUwghhBBCCCGsiBR5QgghhBBCCGFFpMgzrblGBxCvRNrJ/EkbWQZpJ8sg7WT+pI0sg7STZZB2QsbkCSGEEEIIIYRVkTt5QgghhBBCCGFFpMgTQgghhBBCCCsiRZ4QQgghhBBCWBEp8oQQQgghhBDCikiRJ4QQQgghhBBWRIo8IYQQQgghhLAiUuQJIYQQQgghhBWRIk8IIYQQQgghrIgUeUIIIYQQQghhRaTIE0IIIYQQQggrIkWeEEIIIYQQQlgRKfKEEEIIIYQQwopIkSeEEEIIIYQQVkSKPCGEEEIIIYSwIlLkCSGEEEIIIYQVkSJPCCGEEEIIIayIFHlCCCGEEEIIYUWkyBNCCCGEEEIIKyJFnhBCCCGEEEJYESnyhBBCCCGEEMKK2Bkd4E1kzZpVe3h4GB1DCCGEEEIIIQxx8uTJQK11tqRes8giz8PDAy8vL6NjCCGEEEIIIYQhlFK3nveadNcUQgghhBBCCCtikiJPKdVQKXVZKeWrlPo6idenKKW8E7+uKKWePvNa3DOvbTBFHiGEEEIIIYRIq5LdXVMpZQvMBOoBd4ATSqkNWusLf2+jtR7wzPZ9gfLPHCJCa10uuTlE0qLjorGzscNGyU1bIYQQQggh0gJTjMmrDPhqra8DKKVWAM2AC8/Zvh0wwgTnFc8REx/DH1f+4A/fP7j46CJOdk58UOADBlQcQHqH9EbHE0IIIYQQwuRiYmK4c+cOkZGRRkcxKUdHR/LkyYO9vf0r72OKIi834PfM4zvA20ltqJTKB+QH9jzztKNSyguIBcZprdc9Z98eQA8Ad3f35Ke2UgFhAfTd05dLjy9R0q0k3Up342HEQ9ZeXcuZh2f4reFvUugJIYQQQgirc+fOHTJkyICHhwdKKaPjmITWmkePHnHnzh3y58//yvul9uyabYE1Wuu4Z57Lp7X2V0oVAPYopc5pra/9d0et9VxgLoCnp6dOnbiWxT/Un45bOxIaE8rkmpOp6173n//g9fPVp++evnx18Cum15qOrY2twWmFEEIIIYQwncjISKsq8ACUUri5ufHw4cPX2s8UA7X8gbzPPM6T+FxS2gLLn31Ca+2f+Od1YB//Hq8nXlF4TDj99vQjPCac3xr+Rr189f71H/y9PO/xdeWvOXDnACsurzAwqRBCCCGEECnDmgq8v73J38kURd4JoLBSKr9SyoGEQu5/ZslUShUDXIEjzzznqpRKl/h9VqAqzx/LJ54jXsfzzV/f4PvUlwk1JlAsS7Ekt2tTtA1Vc1fl59M/ExAWkMophRBCCCGEEKkh2UWe1joW6ANsBy4Cq7TWPkqpUUqpps9s2hZYobV+tqtlccBLKXUG2EvCmDwp8l7Tiksr2HV7F19W/JKquas+dzulFN+8/Q2x8bFMOzUtFRMKIYQQQghh/caMGUPJkiUpU6YM5cqV49ixY8/dtmbNmhQtWpSyZctSqVIlvL29TZbDJGPytNZbgC3/ee67/zz+Pon9DgOlTZEhrbodfJupp6ZSNXdVPi3x6Uu3z5shLx8X+5jffH6je+nuFMhcIBVSCiGEEEIIYd2OHDnCpk2bOHXqFOnSpSMwMJDo6OgX7rNs2TI8PT1ZuHAhgwcPZufOnSbJktoTrwgTG3d8HHbKjpFVRr5yf93OpTqz8vJKZp2ZxcQaE1M4oRBCCCGEEKlr/PHxXHp8yaTHLJalGF9V/uq5r9+7d4+sWbOSLl06ALJmzQrA7t27GTRoELGxsVSqVInZs2f/s83fqlSpwoQJE0yWVVbItmCH/Q9z0P8gn5X9jBwuOV55P1dHV9oWa8uOmzu4E3InBRMKIYQQQgiRNtSvXx8/Pz+KFClCr1692L9/P5GRkXTq1ImVK1dy7tw5YmNjmT179v/su23bNpo3b26yLHInz0LFxccx8eRE8qTPQ7ti7V57/3bF2rHIZxHLLy1ncKXBKZBQCCGEEEIIY7zojltKSZ8+PSdPnuTgwYPs3buXNm3aMHToUPLnz0+RIkUA6NixIzNnzuSLL74AoH379kRHRxMaGmrSMXlyJ89CrfNdx9UnVxlQcQAOtg6vvX9Ol5zUz1efP67+QXhMeAokFEIIIYQQIm2xtbWlZs2ajBw5khkzZrBu3boXbr9s2TKuX79Ox44d6du3r8lySJFngcJiwvj59M+Uz16eevnqvfFxPi7+MaExoWy/ud2E6YQQQgghhEh7Ll++zNWrV/957O3tTcGCBbl58ya+vr4ALFmyhBo1avxrP6UUo0eP5ujRo1y6ZJpxhFLkWaD55+bzKPIRgzwHJWvBx7LZyuKR0YP119abMJ0QQgghhBBpT2hoKB07dqREiRKUKVOGCxcuMG7cOBYuXEjr1q0pXbo0NjY2fP755/+zr5OTEwMHDjTZ5CsyJs/CBEYEsvTiUhp6NKRMtjLJOpZSimaFmjHt1DT8gv3ImzGviVIKIYQQQgiRtlSsWJHDhw//z/N16tTh9OnT//P8vn37/vV44MCBJssid/IszPxz84mOi6Z3ud4mOd4HBT5AoeRunhBCCCGEEFZCijwLEhAWwKrLq2hasCkemTxMcsycLjmpkqsKG65tIF7Hm+SYQgghhBBCCONIkWdB5p2bRzzxfFb2M5Met2nBptwLu8ep+6dMelwhhBBCCCFSk9ba6Agm9yZ/JynyLMTD8If8cfUPmhdqTu70uU167Jp5a+Jg48Cu27tMelwhhBBCCCFSi6OjI48ePbKqQk9rzaNHj3B0dHyt/WTiFQux9OJS4nQcXUp2MfmxXexdqJq7Krtu7WJIpSHYKKn9hRBCCCGEZcmTJw937tzh4cOHRkcxKUdHR/LkyfNa+0iRZwFCokNYdXkV9fLVS7EZMOvlq8dev72cDzyf7Fk7hRBCCCGESG329vbkz5/f6BhmwSS3bJRSDZVSl5VSvkqpr5N4vZNS6qFSyjvxq9szr3VUSl1N/OpoijzWZtXlVYTGhNKllOnv4v2tRt4a2NnYsfPWzhQ7hxBCCCGEECLlJbvIU0rZAjOBRkAJoJ1SqkQSm67UWpdL/JqXuG8WYATwNlAZGKGUck1uJmsSFRfF0otLqfJWFUq4JfXPahoZHTLyzlvvsPPWTqvqxyyEEEIIIURaY4o7eZUBX631da11NLACaPaK+zYAdmqtH2utnwA7gYYmyGQ1Nl7bSGBEIF1Kp9xdvL/Vy1cP/1B/Lj2+lOLnEkIIIYQQQqQMUxR5uQG/Zx7fSXzuv1oqpc4qpdYopf4eWPaq+6ZJcfFxLDy/kBJuJXg759spfr6aeWtio2zY47cnxc8lhBBCCCGESBmpNY3iRsBDa12GhLt1i173AEqpHkopL6WUl7XNmPM8u2/v5nbIbbqU6oJSKsXPl8UxCxWyV2D37d0pfi4hhBBCCCFEyjBFkecPPDvlY57E5/6htX6ktY5KfDgPqPiq+z5zjLlaa0+ttWe2bNlMENu8aa1ZcH4B7hncqeteN9XOW9u9NlefXMUv2O/lGwshhBBCCCHMjimKvBNAYaVUfqWUA9AW2PDsBkqpt5552BS4mPj9dqC+Uso1ccKV+onPpXnHA47j88iHTqU6YWtjm2rnre1eG0Du5gkhhBBCCGGhkl3kaa1jgT4kFGcXgVVaax+l1CilVNPEzfoppXyUUmeAfkCnxH0fA6NJKBRPAKMSn0vz5p+bj5ujG00LNn35xiaUO31uimcpLkWeEEIIIYQQFsoki6FrrbcAW/7z3HfPfD8UGPqcfRcAC0yRw1pceHSBI/eO0L9Cf9LZpkv189d2r80s71kERgSS1Slrqp9fCCGEEEII8eZSa+IV8RoWnl9Ievv0tCnaxpDz13Gvg0az57bMsimEEEIIIYSlMcmdPGE6fsF+7Li1g44lO5LBIYMhGQplLoR7Bnf23N7DR0U/MiSDEGlZeEw4Fx5dwC/Ej/DYcCJjI7GzsSOnS07eeesdMqXLZHREIYQQQpgxKfLMzPzz87FVtnQo3sGwDEop6rjXYcnFJYREhxhWbAqR1gRGBPL7xd9ZcWkFITEhSW5jq2ypn68+HUt2pGTWkqmcUAghhBCWQIo8MxIQFsD6a+tpWbgl2Z2zG5qltnttFvos5OCdgzQu0NjQLEJYuytPrrDy0krW+a4jJj6Guvnq0rxQcwpmLoiLnQvp7NIRGx/LtafX2HlrJ39c/YOtN7dSOWdl+lfoT5lsZYz+KwghhBDCjEiRZ0YWnF8AGrqU6mJ0FMpkK0NWp6zsvr1bijwhUohPoA/TTk3jyL0jONg40KRgEzqV7IRHJo8kty+XvRzlspejZ9merL26loXnF9J+S3u6lOpC3/J9sbORH+lCCCGEkCLPbDwMf8jaK2tpWqgpudLnMjoONsqGWnlrsfn6ZqLiogyZ5VMIaxWv41lwfgEzTs8gU7pMDKg4gA8LfUhmx8yvtH96h/R0LNmR1kVaM9FrIgvOL+D60+tMrDlR3qtCCCGEkCLPXCzyWUSsjqVrqa5GR/lHHfc6rL6ymqN3j1Ijbw2j4whhFa49vcboo6M5ef8kDTwaMKLKiDce9+ps78x3Vb6jsGthfjz2I/329GNqrak42TmZOLUQwgj3w+6z8fpGzj48i+9TX+Li48idITflspWjXr56FHcrbnREIYSZkiLPDDyOfMyqK6tonL8x7hndjY7zj8o5K5PBPgO7b++WIk+IZIqMjWT2mdks9lmMs70zo94dRfNCzVFKJfvY7Yq1w9HWkRGHR9BrVy9m1JmBi72LCVILIYxwPvA8yy4uY9vNbcTGx+KR0YPiWYrjYOvAjaAbLDi/gF/P/co7b71DjzI98MzhaZKfJUII6yFFnhlYemEpkbGRdC/d3ego/2Jva897ed5jn98+YuNjZbyPgQLCAvB+6E1ETAQx8TE42TnhbO+Mi70LznbOuDq6ktMlJ/Y29kZHFUkICAug/97+XHh0gWYFm/Gl55dkccxi0nO0KNyCdLbpGPbXMD7b+Rmz6s4io0NGk55DCJFy4uLj2Ou3l8UXFnP6wWlc7F1oU7QNHYp3IE+GPP/aNiQ6hDVX1rD4wmK6bO9ChewV6F+hPxVyVDAovRDC3CittdEZXpunp6f28vIyOoZJBEUF0WBtA6rmqsqkmpOMjvM/dtzcwcD9A1nQYAGVclYyOk6a8yTyCaOOjGLX7V0v3TadbTpq5a1F51KdKeFWIhXSiVcRHB3Mx5s/JjAikLHVxlLLvVaKnm/XrV0MPjCYwpkLM6/BPCn0hLAA+/z28dOJn/AL8SN3+ty0L96eFoVakN4h/Qv3i4qL4o+rf/Dr2V95GPGQmnlq0r9Cfwq5Fkqd4EIIQymlTmqtPZN8TYo8Y80+M5tZ3rNY02QNRbMUNTrO/wiPCee9Fe/xUdGP+KryV0bHSVOO3TvGsIPDeBz1mK6lulLbvTaZ02XGVtkSGRdJWEwY4THhhMeG8yjiET6PfNh2cxvBUcG0K9aOLyp+IWOzDBYXH0fvPb05du8Y8+vPT7Wr7AfuHKD/nv5UyVWFn2v/jK2NbaqcVwjxeoKjgxlzdAxbbmyhYKaC9Cnfh1p5a732ezYiNoJlF5ex4NwCwmLDaFGoBYM8B720SBRCWDYp8sxUaHQoDdY2oEKOCvxc+2ej4zxXn919uPrkKttabpM+/6kgJi6GGd4zWHh+Ifky5uOn6j+98uD64OhgZp6eye+XfqdApgKMrz6eYlmKpXBi8TyTT05m4fmFfFflO1oXaZ2q5151eRWjj47mszKf0ad8n1Q9txDi5XwCfRiwbwAPwh/wWdnP6FaqG/a2yety/zTyKXPPzWXZxWXkdM7Jj+/9SMUcFU2UWAhhbl5U5Nmkdhjx/1ZcXkFwdDCflfnM6CgvVMe9DnfD7nLp8SWjo1i928G3+WTrJyw4v4CWRVqy8oOVrzV7WkaHjAx9eyhz680lJDqEdpvbschnEfE6PgVTi6Rsvr6ZhecX0qZom1Qv8AA+KvoRTQs25ddzv3Lq/qlUP78Q4vm8ArzouqMrCsXiRovpWbZnsgs8gMyOmRlSaQiLGi7CzsaObju6se3mNhMkFkJYGinyDBIcHczC8wupmrsqpbKWMjrOC9XIWwMbZcPu27uNjmK1YuJjmH9uPi03tMQvxI/JNSczosoInO2d3+h4VXJV4Y+mf1AjTw0mek2ky/Yu+D7xNXFq8Tw+j3wYcXgEFXNUNLSb87C3h5HLJRfD/hpGSHSIYTmEEP/v6L2j9NzVk+zO2VncaDFlspUx+TnKZS/H8g+WUyZrGYbsH8LKSytNfg4hhHkzSZGnlGqolLqslPJVSn2dxOtfKqUuKKXOKqV2K6XyPfNanFLKO/FrgynyWILfzv9GcHQw/cv3NzrKS2VxzEKF7BWkyEsh3g+8+WjjR0w9NZV3c73L2qZrqZevXrKPm9kxM1NqTmHUu6O4+uQqrTe2ZsbpGcTFx5kgtXiex5GP+WLvF2RxzMLkmpMNnfHUxd6Fse+NJSAsgLHHxhqWQwiR4OzDs/Tb0488GfKwsMFCcrjkSLFzZXTIyC/1fqF6nur8cOwHfjv/W4qdSwhhfpJd5CmlbIGZQCOgBNBOKfXfqf1OA55a6zLAGuCnZ16L0FqXS/xqmtw8liAwIpClF5fS0KOhxSxkWse9Dr5PfbkdfNvoKFYjMjaS8cfH88nWTwiNCWV6relMqz2NnC45TXYOpRQtCrdgU4tNNMrfiDln59B7d28iYyNNdg7x/2LjYxlyYAiPIx4ztdZUky+T8CbKZS9HjzI92Hh9I9tuSLctIYzi+8SXXrt74eboxtx6c3FzckvxczrZOTGl1hQaejRk0slJLL+0PMXPKYQwD6a4k1cZ8NVaX9daRwMrgGbPbqC13qu1Dk98eBTIQxo29+xcouOiLWoyhNrutQHYcWuHwUmsQ0h0CN13dGfpxaW0LdqW9c3Wp+jU+q6Orvz43o98V+U7Dt89zOADg4mNj02x86VVs8/M5ti9YwyvMtyslrHoUaYHZbKVYdTRUdwLvWd0HCHSHP9Qfz7b+Rn2NvbMrT+XbM7ZUu3c9jb2/Pjej9TKW4sfj/3In1f/TLVzCyGMY4rVrXMDfs88vgO8/YLtuwJbn3nsqJTyAmKBcVrrdUntpJTqAfQAcHd3T05eQ/mF+LH6ymo+LPwh+TLme/kOZiJX+lyUz16eTdc20bVUV5llMxkiYyP5fOfnXHh8gUk1JlHfo36qnbt1kdbExsfy47EfmXxyMkMqDUm1c1u7K0+usODcApoWbErzQs2NjvMvdjZ2jKs2jlYbWzHsr2HMqz9PllVIZVprfB75sOf2Hu6H3ycyNpJ4HU925+yUy16O93K/J9PdW6nAiEB67OhBRFwEvzX8jbwZ8qZ6BnsbeybWmEi/Pf0YcXgEbk5uVM9TPdVzCCFSjymKvFemlOoAeAI1nnk6n9baXylVANijlDqntb7233211nOBuZCwhEKqBE4Bs7xnYatszX5GzaQ0KdiEUUdGcfHxRbO6S2FJtNZ8f+R7zgaeZUrNKdTNVzfVM7Qr1o6bQTdZcmEJJd1K8n6B91M9g7WJ1/GMPDKSDA4ZGOw52Og4ScqbMS9D3x7K8EPD+c3nN7qW7mp0JKv3OPIx+/32c+rBKY7fO87dsLvYKTtyuOTAwdYBheLQ3UP8ful37G3seeetd6ibry7189WXgs9KBEcH03NXTx5GPGRuvbkUcS1iWBYHWwem1JpCx60d+erAVyx7fxkFMhUwLI8QImWZosjzB569LJUn8bl/UUrVBb4Bamito/5+Xmvtn/jndaXUPqA88D9FnjW48uQKm69vplOpTik62Dql1M9Xn7HHxrLx2kYp8t7Qxusb2Xx9M73L9TakwPvboEqDuPT4Et8f/p5CmQtRNEtRw7JYg1WXV3H24Vl+rPYjmR0zGx3nuZoVbMaBOweY5T2LuvnqWlRvAktyN/Quc8/OZb3vemJ1LK7pXCmbrSw9y/WkVt5aZEqX6Z9t4+Lj8H7oze7bu9lzew8jDo9g8snJdCjegZaFW6Zqtz5hWhGxEfTd3Rffp77MqD2DctnLGR0JJzsnptWaRtvNbem/pz/L3l9GRoeMRscSbyAuPo4H4Q+IjIvEyc4JR1tHHO0cSWebTnpbCcAEi6ErpeyAK0AdEoq7E8DHWmufZ7YpT8KEKw211lefed4VCNdaRymlsgJHgGZa6wsvOqelLobed09fTgacZGvLrf/6JW9Jvtz3JSfvn2RX612GzhpoiR5FPKLZ+mZ4ZPRgcaPF2ChjVzAJjAikzaY22NvYs/KDlRb7f9Jo98Pu02x9M8pkLcOcenPM/pdrYEQgTf9sSsmsJZlbb67Z57UkAWEB/Hr2V/7w/QOFomXhlrQs0pKirkVf6d9Za83ZwLPMOTOHg/4HsVW21Mxbk4+KfESVXFWkrSxIbHws/ff25+Cdg/xU/Sca5m9odKR/OXX/FF13dOXtnG8zs85M6b5txu6E3OF60HX8Qvz++bodfBv/UH9i4mP+Z3sbZUNWx6zkcMlBDucc5HDJgXsGd6rkqoJHRg/5OWJlXrQYerLv5GmtY5VSfYDtgC2wQGvto5QaBXhprTcAE4D0wOrE/1y3E2fSLA7MUUrFkzAJzLiXFXiW6uzDs+zz20efcn0s+sN004JN2XlrJ0fuHpH+/K9p/InxhMeEM/LdkYYXeABZnbIypeYUOm3rxJADQ5hVZ5b8on8D40+MJzY+luHvDLeIX55ZnbLSr0I/xhwbw5YbW6S7rgncD7vPvHPzWHt1LRpNy8It6Va622vPlKuUomy2ssyqO4ubQTf54+ofrPNdx+7bu6mWuxrfvP0NeTKk6XnLLMZPJ37iwJ0DDH9nuNkVeAAVclTgm7e/YeSRkUw5OYVBlQYZHUk840nkk3/e/zeDb/7zvLOdM+4Z3SnsWpha7rXImyEvLnYuRMZFEhEbQWRsJGExYQRGBHI//D43gm5w9N5RQmNCAciXMR/NCzWnVeFWZt3rRJhGsu/kGcES7+R139Gdy48vs7XlVlzsXYyO88Zi4mOos6oOld+qzMQaE42OYzH2++2nz54+9Crbi57lehod51/WXFnDyCMj6VqqK19U/MLoOBblsP9hPtv1Gf3K96N7me5Gx3llcfFxfLL1E/xD/fmz2Z9msdSDJYqIjWC292yWXVxGvI6neeHmdC/dnVzpc5nsHNFx0ay8vJIZp2cQr+PpVa4XHUp0kJ4UZmz5peX8eOxHOpXsxEDPgUbHeaExR8ew4vIKfqz2I00KNjE6TprnE+jD75d+Z9uNbUTHR+OZw5O6+epS0q0keTPkJYtjlje6mOgX4sch/0Nsv7kdr/teONk50aZoGz4t8al0CbdwL7qTJ0VeKjgRcIIu27swyHMQHUt2NDpOso09NpY1V9aw56M9Fn1XMrUERwfTYl0LMqbLyKoPVmFva34fzkYeGcmaK2vkF/1riImL4cMNHxKv4/mz2Z842DoYHem1XH1ylY82fUQ993r8VOOnl+8g/uVEwAlGHB6BX4gfzQo24/Oyn6foXbaAsAB+PPYje/32UtS1KJNqTpIxlWZo562dDNo/iOp5qjO15lSz7x0REx/DZzs/4+zDsyxrvEzGZxsgNj6WrTe2suLSCs4GnsXJzommBZvStmhbCrkWMvn5rj65yvzz89l6Yyu2ypYWhVrQqVQnQ2Z9Fcn3oiLP+D5jVk5rzfRT08nulJ02RdsYHcckWhRuQXR8NJuubzI6ikWY7DWZwMhAfqj6g1kWeADDKg+jUs5KjDg8gtMPThsdxyIsvbiUm8E3+aryVxZX4AEUdi3M52U+Z+vNrey6tcvoOBYjLCaMH47+QJftXdBas6DBAn6o9kOKd6PM6ZKT6bWnM7XWVB6EP6Ddpnb85f9Xip5TvJ5D/ocYcmAIZbKWYfx7482+wIOEpRV+qv4TGRwyMGj/IEKjQ42OlKZcfnyZ9lvaM+yvYQRHB/N15a/Z3Xo3377zbYoUeJDws3/ce+PY1HwTzQs150/fP2nyZxOGHhzK9aDrKXJOYQwp8lLYQf+DeD/05rOyn+Fo52h0HJMolqUYpdxKsebKGizxTnBqOnz3MGuvrqVTyU6UzFrS6DjPZW9rz5SaU8iVPhf99/THL8Tv5TulYQ/CH/DLmV+okaeGRY9N7VK6C8WzFGfMsTHy4e4VnH14lhbrW7Dq8io+KfEJa5uupVLOSqmaoY57HZZ/sJxc6XPRa1cvFpxfID+HzYBXgBcD9g2gUOZCzKw7E2d7Z6MjvbKsTln5qfpP3A65zeijo42OkyZorVnks4i2m9oSEBbAhOoTWN98Pe2LtyeDQ4ZUyZA3Y16+q/Id21puo0PxDuy+vZtWG1qxyGcR8To+VTKIlCVFXgqK1/HMOD2D3Olz06JQC6PjmFSrIq3wferLmYdnjI5itsJjwhl5eCQeGT3oWda8xuElJVO6TMysM5N44hm0f1CSs3aJBDNOzyAmPsbiF5O3t7Hnuyrf8SjiETO9Zxodx6wdvHOQbju6YatsWdxoMUMqDTHsg3zu9LlZ3Ggx9T3qM+XkFL46+BVRcVEv31GkCO8H3vTe3Zu3XN7il7q/WOSSBJVyVqJn2Z5subGF7Te3Gx3HqoXFhPHlvi+Z6DWRGnlrsL7Zehrmb2jYhGzZnbMzqNIgtrXcRvU81ZnoNZHuO7oTEBZgSB5hOlLkpaBdt3Zx8fFFepXrZbbd9N5Uo/yNcLZzZvWV1UZHMVtTT03lXtg9RlUdZTF3cfNlzMf3Vb7nwqMLzDs7z+g4ZulW8C02XNtAm6JtcM/obnScZCuVtRStirRi+aXlXH582eg4ZmnT9U3029MPj4weLGm8xCzWO3O2d2ZC9Qn0r9CfrTe20mNHD4KigoyOleb4BPrQc1dPsjlnY179ebg5uRkd6Y11K92NUm6l+OHoDwRGBBodxyo9jXxKt+3d2Ou3l0Geg5hSc4rZzHKZxTELU2pOYdS7ozgXeI4PN3woXcItnBR5KSQuPo6Z3jMpkKkA7+e3vinKne2deb/A+2y/uV0+WCTh5P2TLL+0nPbF21M+e3mj47yWuvnq0jh/Y+aenSsf+pMw+8xsHGwd6Fq6q9FRTKZ/hf5kdMjImGNjpJvOfyz2WczQg0OpkKMCCxosIKtTVqMj/UMpRbfS3ZhQfQLnAs/x6dZPuRt61+hYaca90Hv02t2LTOkyMa/+PIufpdDOxo4x1cYQHhPOd4e+k58FJvYg/AGdt3fmypMrTKk5hY4lO5rdsjtKKVoUbsGaJmvI5ZKL3rt7s8hnkXQJt1BS5KWQrTe3cj3oOr3L9baIwddvolWRVkTFRbH5+majo5iViNgIvjv0HbnT56Zv+b5Gx3kjQysPJWO6jIw8MpK4+Dij45gN3ye+bLm+hbbF2prVh/3kypQuEwMqDuD0g9NsuLbB6DhmY+H5hUzwmkC9fPWYVXcW6R3SGx0pSQ3zN2ROvTk8DH9Ihy0d5OJMKgiPCafvnr5Ex0Uzq86s114T0VwVyFyAgZ4DOeh/kMU+i42OYzXuht6l49aO3A29y+y6s6nlXsvoSC/kntGdxY0WU8e9DhO9JvLtoW+Jjos2OpZ4TVLkpYC4+Djmnp1LYdfC1M1X1+g4KaaEWwlKupVkzVWZgOVZs7xncTvkNiPfHWlRg++fldkxM0MqDeFc4DmWX1pudByzMevMLJzsnOhcsrPRUUyuWaFmlM1Wliknp8jdeWDjtY1MPjmZhh4NmVB9Auls0xkd6YUq5azEokaLsFE2dNzWkcN3DxsdyWrF63iGHhzK1adXmVBjAgUyFzA6kkm1K9aOuu51mXZqmoy7N4E7IXfovK0zQVFB/Fr/Vyq/VdnoSK/E2d6ZSTUm0atcLzZc20D3Hd15EvnE6FjiNUiRlwJ23trJjaAb9CjTw7CBtKmlVZFWXH1yVX4RJLr46CKLLyymVZFWvP3W20bHSZbG+RtTLXc1pp+ejn+ov9FxDOcT6MPOWzvpWLIjro6uRscxORtlw7fvfMvTqKdMPzXd6DiGOux/mO8OfUflnJUZU22MxfTGKOxamKWNl/4z8+bSC0vlAlwKmOU9iz1+exjkOYhquasZHcfklFKMrDqSHC45GLx/sFz0SQa/YD86b+9MaEwovzb4lTLZyhgd6bUopehZticTakzA55EPH2/+mOtP09YyC+cDzzP80HB23tppdJTXZt0ViAHidTxzzs6hQKYC1HOvZ3ScFPf3BCxrrqwxOorhtNaMOz6OzOkyM6DiAKPjJJtSiuHvDAdg9NHRaf7D4vTT08mcLjOflvjU6CgppliWYrQv3p5VV1ZxIuCE0XEMceHRBQbsG0CBzAWYWmuqxa2BmNMlJ0saLaF6nuqMPzGe4YeGSzcrE9p1axdzzs6heaHmdCjeweg4KSajQ0Ym1pjIw4iHfHvo2zT/8/9N3Ay6SaftnYiMjWR+g/mUdDPfZZRepqFHQxY2WEhEbAQdtnSw+p4CWmu239xO201tabe5HdtvbrfI8c5S5JnYntt78H3qS48yPSzm6m9yuNi70LhAY7bf3E5wdLDRcQy15cYWTj049c8kFtYgV/pc9K/Qn0P+h9hyY4vRcQxzIuAEh+8eplvpbmY7LstU+pbvS94MeRlxeAQRsRFGx0lV/qH+9NzVk8zpMjO77uxUW6/K1FzsXZhaayqfl/2c9dfW02V7F5kt0QSuPLnCsL+GUSZrGYa/M9zsJs0wtVJZS/FlxS/Z57ePpReXGh3Holx8dJHO2zsTGx/L/AbzKZalmNGRkq10ttIsf385b6V/i167elnt+G2fQB86bO3AoP2DCI8NZ2jloexuvZuOJTsaHe21SZFnQlpr5pydQ76M+Wjo0dDoOKmmVZFWRMZFpukJWCJiI5jsNZmSbiVpXqi50XFMqm3RtpTJWobxx8enyf74Wmumn5pOdqfstCnaxug4Kc7JzomR747EL8QvTXXbjImPYcj+IUTHRTO73myyO2c3OlKy2CgbepfrzaQak7j8+DIfb/5YJmRJhqCoIPrv6U96+/RMqTXF4u7wvqkOxTtQK28tJp+czPnA80bHsQhH7h6h07ZO2NvYs7DBQoq4FjE6ksm8lf4tFjdajGdOT77961s2XttodCSTiYmPYab3TNpvac+90HuMencUfzb9k4+Lf2yxF/ykyDOh/Xf2c+nxJbqX7p4m7uL9raRbSYpnKc7qK6vTbJeOtVfW8iDiAYM8B1ndOExbG1u+f/d7QqJDmHBigtFxUt2BOwfwfujNZ2U/s5j1DpOrUs5KtCnahmUXl3Hq/imj46SKGadncDbwLN+/+z0FMlnPRBr1PerzW6PfiIuPS5iQxd+6u1mlhNj4WAbtH8T98PtMqTXF4i8AvA6lFKOrjiabUzYG7R+U5nvsvMyuW7vovbs3uTPkZmnjpVY3KQ8k9BT4ufbPVM5ZmW8PfWsVF/ivPb1G+83t+eXML7xf4H3WNV9Hi8ItLP6zvEk+jSqlGiqlLiulfJVSXyfxejql1MrE148ppTyeeW1o4vOXlVINTJHHCFprfjnzC7nT56ZxgcZGx0l1rYu25uqTq5wLPGd0lFQXHRfNQp+FeObwxDOnp9FxUkRh18J0Ld2Vjdc3cuDOAaPjpJp4Hc/009PJmyEvLQq3MDpOqhpQcQC50ufim7++ISwmzOg4Keqw/2EWnF9A6yKtaeBhsb+GnqukW0l+f/938qTPQ+89vdl9a7fRkSzKlJNTOHrvKMPfGU7ZbGWNjpPqMqXLxIQaE7gfdp/vD3+fZi/mvszGaxsZuH8gJdxKsLDBQqu+GOBk58T02tOpmKMiw/4axtYbW42O9Ma239xOu83tCAgLYErNKYypNsZqhtwku8hTStkCM4FGQAmgnVKqxH826wo80VoXAqYA4xP3LQG0BUoCDYFZicezOIfuHsLnkQ/dS3fH3sbe6DiprnH+xjjZObH6ymqjo6S69dfW8yD8AT3K9DA6SorqUaYHhV0L892h79JMt83tN7dz5ckVepfrnebe1y72LoypNgb/UH+rvoMbGBHI0L+GUihzIYZUGmJ0nBSTwyUHCxouoIRbCb7c/yXLLi4zOpJF2HhtI4svLKZdsXZp7kLPs8pmK0v/Cv3ZeWun/N9Jwtora/nmr2/wzOHJ3HpzyZQuk9GRUpyzvTMzas+gfPbyDD04lG03txkd6bVorZl3bh6D9g+iiGsR1jZda3XLnpniTl5lwFdrfV1rHQ2sAJr9Z5tmwKLE79cAdVTCiOVmwAqtdZTW+gbgm3g8i6K1ZvaZ2bzl8hZNCzY1Oo4hXOxdaJy/MdtubCMkOsToOKkmJj6G+efmUzprad556x2j46QoB1sHxlYbS1B0UJqYbTNexzPnzBwKZipIo/yNjI5jiIo5KtKpVCfWXl3L7tvWd/fn7/XOwmPCmVB9gtV3x83okJFf6/1K9TzVGXd8HGOPjSVexxsdy2z5BPrw/eHvqZSzEoMrDTY6juE+LfkpNfPWZJLXJE4/OG10HLOx7OIyvj/yPVVzV2VmnZkWuz7um3C2d2ZWnVmUzVaWrw58xcLzCy3is0FcfBxjjo1h2qlpNMrfiAUNFpDNOZvRsUzOFEVebsDvmcd3Ep9LchutdSwQBLi94r4AKKV6KKW8lFJeDx8+NEFs04mNj6V8tvL0LNsTe9u0dbX/Wa2LtE5zE7BsvbEV/1B/epTpYfUzrQEUzVKU3uV6s/PWTvb47TE6Torac3sP14KupYn1Ll+kT7k+lHArwfC/huMX7PfyHSzIgvMLOHrvKF9X/ppCroWMjpMqnO2dmVpzKp+U+ITfL/3O6KOjpdBLQmBEIP339ierU1Ym1piY5u7kJ8VG2TCm2hhypc/FwH0DZcZWYP65+Yw7Po467nWYVmua1V8oSoqzvTOz686mjnsdJp+czMD9A3kc+djoWM8VERvBgH0DWHl5JV1KdWHce+OsdiIli/nkorWeq7X21Fp7ZstmXtW2va09gyoNStNdOQBKuJVIUxOwxMbH8uvZXyniWoQaeWoYHSfVdCzZkfyZ8jP15FRi4mOMjpMitNbMPTsX9wzuVjlG63U42DowueZklFIM2DeAyNhIoyOZhPcDb2acnkFDj4Z8WPhDo+OkKlsbWwZ7DqZb6W6subKGMUfHpImf2a8qJi6GgfsGEhQVxLTa08jimMXoSGYjo0NGJtecTEh0CIP2D7La3wEvo7VmpvdMpp6aSqP8jZhQY4LVFgqvwtnemUk1JvFlxS/Z67eXJn82YdXlVWZ3Aelh+EO67ejGPr99DHt7GAMqDrDqi7im+Jv5A3mfeZwn8bkkt1FK2QGZgEevuK+wEEopWhVpxZUnV9LEVMtbb2zlZvBNepbtmSbu4v3N3saeLyt+yc3gm6y5ssboOCnioP9BLj6+SLfS3Sx+di1TyJ0+N+PeG8flJ5cZf2K80XGSLSgqiK8OfEVOl5x8V+W7NPX+/ZtSin7l+9GlVBdWXVnFmGNS6EHCh/cRh0dw6sEpRlUdZRXrm5la0SxF+a7Kd5y8f5JpJ6cZHSfVaa2ZfHIyv5z5hRaFWjC22li500vCz5TOpTqztslaimUpxuijo+mwpQMXHl0wOhoAh+8eptXGVlx9cpUpNafQrlg7oyOlOFMUeSeAwkqp/EopBxImUvnvCokbgL9XEWwF7NEJv002AG0TZ9/MDxQGjpsgkzDI3xOwrLlqnR/+/xYbH8ucs3Mo6lqU2u61jY6T6mrkqUGlnJWY7T3bKsdgzjs3j5wuOfmgwAdGRzEb7+V5jy6lurDmyhq239xudJw3prVm5JGRPAh/wITqEyx2/SNTUErxRYUv6FyyMysvr2SS16Q0X+jNOjOLjdc30rtc7zQ7FvdVNCnYhDZF27DowiJ23NxhdJxUo7Vm/Inx/ObzG+2KteP7d7+XC4H/USBzAebVn8fY98biH+pPu83tGHtsrGGfFaLioph6ciqf7/ycLI5ZWP7+curkq2NIltSW7CIvcYxdH2A7cBFYpbX2UUqNUkr9PQvJfMBNKeULfAl8nbivD7AKuABsA3prreOSm0kYJ71Dehrnb8zWG1ut8sP/37be2Mqt4Fv0LNvTqm/1P49SioGeA3kS9YTFFxYbHcekTt4/yekHp+lUslOaHmOblD7l+1AmaxlGHh6Jf6hldrpYfWU1O2/tpF+FfpTOVtroOIZTSjGg4gDaFWvHoguLmHduntGRDLP6yup/7s58VuYzo+OYva8qfUWZbGUYfmg4159eNzpOqvjl7C8su7iMT0p8wtDKQ9Pk7/9XoZTigwIfsLHFRj4q8hHLLy2n6bqm/HH1D2LiUqeLr9aafX77aLmhJfPPz6dF4Rb8/v7vFMxcMFXObw6UJV618/T01F5eXkbHEM9xPvA87Ta345u3v6FtsbZGxzG52PhYmq1rhrO9M6s+WJUmu3r97ct9X3LI/xBbW261mnErn+/6nIuPLrKt5Tac7JyMjmN27oTcofXG1hTMXJCFDRdaVDelS48v0X5zeyrlrMSsurPkA9oz4nU83/z1DZuub7Lan90vsu3GNoYcGMJ7ed5jaq2pFvX/2kgBYQG02dSGLI5Z+P393636Z+aqy6sYfXQ0TQs25YeqP6Tp3/2vyyfQhzHHxnAu8Bw5nHPQqWQnPiz8YYrMRKq1xuu+F7+c+YXjAcfxyOjBsLeHUSVXFZOfyxwopU5qrZNcpFl+wwmTK+lWkiKuRdhw7b+9dq3DhmsbuB1ym8/Lfp7mf8j3KdeHyLhI5p+bb3QUk7j46CKH/A/RoXgHq/6wkhx5MuRhRJURnHl4hp9P/2x0nFf2JPIJ/ff0J7NjZsZUGyMF3n/YKBtGVR1FzTw1+fHYj2mqC94h/0MM/Wso5bOXl5k0X1NOl5yMrTaWa0+vMfbYWKPjpJidt3byw9EfqJ6nOt+/+32a/93/ukpmLcmyxsv4pe4v5M2Ql/EnxtNgbQOmn5rOnZA7JjlHeEw4W29spcOWDnTZ3gXfp74MrTyUP5r9YbUF3svYGR1AWB+lFO8XeJ8pJ6fgF+xH3ox5X76ThQiNDmX6qemUy1aO2nnT3li8/yqQuQBNCjRhxaUVtCvWjjwZ8hgdKVmmn55OBvsMtCnWxugoZq1h/oYcDzjOwvMLKelW0uxnII2Nj2Xw/sEERgSyqNEi3JzcjI5kluxt7JlQYwLdd3Tn64Nfk8MlB2WzlTU6VoryfuDNgH0DKJipID/X+Vku7ryBd3O/S7fS3fj13K9UylmJJgWbGB3JpE4EnOCrAwldU+UiwJtTSlE1d1Wq5q6K9wNv5p+fz/zz85l3bh4Vc1Skvkd96uWrR1anrC89ltaa0JhQ7oTc4UTACU4EnODovaNExkWSO31uvn37W5oVapYml7R4lnTXFCniXug96q+tT59yffisrPWMbZh8cjILzy9k+fvLKZW1lNFxzEJAWADN1jWjbLayzKk3x2KvcB6+e5jPdn7GwIoD6VSqk9FxzF50XDRdtnfhypMrLGm0hKJZihod6bl+OvETSy4sYXTV0TQv1NzoOGbvaeRT2m5uS3RcNCs/WGmViwQDXH58mc7bO+OazpVFjRa90odLkbTY+Fi6bu/KxccXWfHBCgpkKmB0JJO49PgSnbd1JrtzdhY3WkymdJmMjmRVAsICWOe7ju03t+P71BeFooRbCQpkKoCbkxux8bFEx0UTHB3Mk6gnPIlM/Ip6Qmx87D/Hcc/gzru53qW+R30qZK+QpibDeVF3TSnyRIrpuLUjT6Oesq7ZOov94P+s28G3aba+Ge/nf58fqv1gdByzsuLSCsYcG2OxH6Lj4uP4aNNHhMWEsb75etLZpjM6kkV4GP6QNpva4GTnxIoPVpjlTJUbr21k2F/DaFesHcPeHmZ0HItx+fFlPtn6CcWyFGNe/XlWtwbYreBbdNzaEVsbWxY3Wkzu9LmNjmTx7ofdp/XG1rg5uVnF+Dy/ED8+3foptsqWpY2XktMlp9GRrJrvE1923NrBqQenuBl0k6dRT3GwccDe1p6MDhnJnC4zro6uCV/pEv7M5pSNCjkqpOm2kSJPGGLlpZX8cOwH1jRZY9ZX+V9Vvz39OHbvGJtabLLaK9tvKl7H03lbZ64+vcqG5hss7or4n1f/5LvD3zGh+gQa5m9odByLcur+Kbps70Jt99pMqjHJrC7onH5wmu47ulMqayl+rf+rdLN6TdtubmPw/sFUzV2VabWmWc3FD98nvvTc3ZPouGgWNlhIgczWcdfJHPzl/xc9d/WkZeGWfP/u90bHeWP+of503d6VkOgQFjdanKZmZBSWRSZeEYao71EfO2XH5hubjY6SbEfuHmGv3166l+kuBV4SbJQN37/7PVGxUfx47Eej47yWiNgIZpyeQZlsZcx+bJk5qpCjAv0r9GfnrZ385vOb0XH+cfbhWXru6slbLm8xqcYkKfDeQEOPhox8dySH/Q/Td3dfImIjjI6UbPv89tF+S/uEtU7rzZECz8Sq5a5Gt9LdWHt1LZuubzI6zhu5HXybTts6ERwdzJx6c6TAExZLijyRYlwdXXkn1ztsu7GNeB1vdJw3Fhsfy08nfiJ3+tx8UuITo+OYrfyZ8tOzXE923trJzls7jY7zypZfWs6DiAcMrDjQrO5CWZJOJTtRL189Jp+czDrfdUbH4fLjy3y+K2Hh23n158lEK8nwYeEPGV11NEfvHaXP7j6Ex4QbHemNaK2Zd24e/fb0wyOTB8vfX06xLMWMjmWVepfrTYXsFRh1ZBQ3gm4YHee1XA+6TudtnYmMjWRBgwUy9l5YNCnyRIpqnL8x98Lu4f3A2+gob2z1ldX4PvVlsOdgq+mulFI6luxI8SzFGXN0DMHRwUbHeanQ6FAWnF9AtdzVqJCjgtFxLJZSinHvjaPKW1UYcXgEu27tMizL9aDr9NjZAxd7F+bVn0cOlxyGZbEWzQo1Y0y1MXjd96LX7l4W8d5+VmRsJF8f/Jppp6bR0KMhixouStNjeFKanY0d46uPx9HWkX57+lnM/5erT67SZVsXYnUsCxoskIsAwuJJkSdSVG332jjaOrLlxhajo7yRoKggZnrPpHLOytR2lyUTXsbexp6R747kceRjZnvPNjrOSy25sISgqCD6lO9jdBSL52DrwNRaUymdtTRDDgzh6L2jqZ7hZtBNuu/oDsCv9X4lV/pcqZ7BWjUp2IRx743jzMMztN/c3mLu0ASEBdB5W2e23NhCv/L9EoqPND6temrI6ZKTSTUncSfkDkP2D/nXTIjm6Hzgebpu74qNsmFhw4UUdi1sdCQhkk2KPJGiXOxdqJG3Bjtu7iAmPsboOK9tlvcsQqJDGFJpiHTle0XF3YrTskhLVlxawfWn142O81xBUUEsvrCYuu51KelW0ug4VsHZ3pmZdWaSL2M++u/pz/nA86l27vOB5/l066fExscyt95cPDJ5pNq504pG+Rsxr/48gqODab+5PUfuHjE60gttv7mdlhtacj3oOtNqTaN7me7yczwVVcpZiW/f+ZZDdw8xyWuS0XGSpLVmne86Om7tiLO9MwsbLrSa5R+EkCJPpLjG+RvzJOoJR++m/pX95LgedJ2Vl1fSqnArq5gdNDX1Ld8XJzsnxp8Yj7nO4Lvw/ELCYsLoVa6X0VGsSqZ0mZhTbw6ujq703NUzVQr94/eO02V7F5ztnVncaLG8X1NQxRwVWf7+cnKmz0mvXb1Y7LPY7MZcB0UF8dWBrxi0fxD5MuZjdZPV0hPDIC2LtKRD8Q4svbiUNVfWGB3nX4KjgxlyYAjDDw2nXPZyLH9/Ofky5jM6lhAmI0WeSHHVclcjg0MGi+uyOe9swtpQvcv3NjqKxcnimIWe5Xpy+O5h9t/Zb3Sc/xEYEcjvl36nUf5G0i0nBWR3zs7cenOxVbZ029GNS48vpdi5Dtw5QK/dvcidPjdLGi2RD2mpIFf6XCxuuJhqeaoxwWsCn+/8nAfhD4yOhdaabTe20Xx9c7bf3E6vsr1Y1GgR7hndjY6Wpg30HEjVXFX54egPHLhzwOg4AJy8f5JWG1qx89ZO+pXvx9x6c3F1dDU6lhAmJUWeSHEOtg7Uz1ef3bd3W8wU3HdC7rDlxhZaF2lNFscsRsexSG2LtaVApgJMODGB6Lhoo+P8y/xz84mOi5a7eCnIPaM78+rPw9bGlo5bO6bIh7vtN7fTf29/CmQqwIIGC2R5k1SU3iE902tNZ/g7wzn94DQt1rdg2cVlhr3X/UL86LmrJ4MPDCabUzaWvb+MnuV6ytIZZsDOxo6JNSZSxLUIA/cN5MzDM4Zl8QvxY8j+IXTa1gk7GzuWNFpC9zLdsbWxNSyTECklWUWeUiqLUmqnUupq4p//cxlEKVVOKXVEKeWjlDqrlGrzzGu/KaVuKKW8E7/KJSePMF+N8zcmIjbCLO/qJOU3n9+wUTZ8WuJTo6NYLHsbe4ZUGsLtkNssvbjU6Dj/8Av2Y9XlVTQr1Ezu+qSwQq6FWNZ4Gfky5qPvnr6svLTSJMeNiotiyskpDNo/iFJupZjXYJ5chTeAUoqPin7EqiarKO5WnHHHx1FvTT2mnZrGnZA7qZLhRtANRhweQbN1zfB+6M3Xlb9m+fvLZZytmUnvkJ5ZdWeRzTkbvXf35npQ6o7XfhL5hHHHx9F0XVP23dlHjzI9WN1kNaWzlU7VHEKkJpWc8TJKqZ+Ax1rrcUqprwFXrfVX/9mmCKC11leVUrmAk0BxrfVTpdRvwCat9Wt11Pb09NReXl5vnFukvrj4OOqvqU/JrCWZXnu60XFe6GH4QxqubUjTQk0ZUWWE0XEsXt/dfTkecJxNLTYZfqdFa02PnT04F3iO9c3Wy/T6qSQ8JpzBBwZz4M4BOpXsxICKA7BRr3+NUWvNHr89TDwxkTuhd2hVpBVfV/5aljYxA1prjgUc4/eLv7P/zn7idTxv53ybOvnq8G6ud3HP4G6ySU9i42M5+/AsSy4sYfft3TjYOtC8UHO6l+4u72kz5xfsR4etHUhnm44ljZakeHtFxEaw9MJSFpxfQHhsOB8W/pBeZXsZ/rtICFNRSp3UWnsm+Voyi7zLQE2t9T2l1FvAPq31C0e8K6XOAK0Si77fkCIvzZhwYgK/X/qdfR/tI1O6TEbHea7JXpNZdGERm5pvIm/GvEbHsXi3g2/TbH0z3s//Pj9U+8HQLBuvbWTYX8P45u1vaFusraFZ0prY+FjGHx/PissrqJSzEt+8/Q0FMxd85f19n/gy/sR4jt47SqHMhRhSaQhVclVJwcTiTQWEBbDOdx0brm3AL8QPgNzpc1MlVxUKZS5E7vS5//lytnd+7nHidTwh0SE8jXrKo4hHnAs8x4mAE5y8f5LQmFAyOGSgbdG2tC/eXha8tyAXHl2g87bO/4zdfSv9WyY/R7yOZ8O1Dfx86mceRDygVt5afFHhCwpklpkzhXVJySLvqdY6c+L3Cnjy9+PnbF8ZWASU1FrHJxZ5VYAoYDfwtdY66jn79gB6ALi7u1e8devWG+cWxvB55EPbTW35vsr3tCzS0ug4SQqKCqL+mvrUzFuT8dXHGx3Hakw+OZmF5xeypNESymUvZ0iGJ5FPaLauGXkz5mVJoyVvdCdJJI/Wmj99/2SS1yTCYsJoVaQVPcv2fO4HdK01xwOOs8hnEX/5/0V6h/T0LtebNkXbYGdjl8rpxevSWuMX4sehu4c4fPcwJwJOEBYT9q9tMqXLROZ0mVEk3OVzsnMiKi6Kp1FPCYoKIk7H/Wv7fBnzUSlnJSrnrEz1PNVxsXdJtb+PMJ2T90/Sd3dfnOyd+KXuLyadAOt84HnGHhvL2cCzlMlahoGeA6mQo4LJji+EOUlWkaeU2gXkTOKlb4BFzxZ1SqknWuskB0b8facP6Ki1PvrMcwGAAzAXuKa1HvWyv5DcybNMWmuarmtKdufszG8w3+g4SZp9ZjazvGextulairgWMTqO1QiLCaPF+hYoFKuarDLkTu63f33L5uubWdlkpbStwR5HPma292xWX1mNo50jHUt2pHbe2rg5uWGn7IjVsRy5e4QVl1dw9uFZsjplpWXhlrQv3l7G3lkwrTWPIh/hH+qPf4g/d8PuEhAWQHBUMJqEzyIRsRE42Drgms6VTOky4eroSuZ0mcmcLjOFXQuT0yWpjyPCEl1+fJnPd31OSHQIvcv15pMSnyTr4s3jyMdMPzWdP67+QRbHLHzp+SUfFPhALugJq2Z4d02lVEYSCrwfn9c1UylVExiktf7gZeeVIs9yzfaezewzs9nZaqfZjZ0Ijwmn/tr6lM9enp9r/2x0HKtz7uE5Pt32KVVzVWV67emp+ov3+L3jdN3RlW6lu9G/Qv9UO694sRtBN5hycgp7/fYm+Xqe9HnoXKozzQo1k3F3QlihB+EP+OHoD+z120sJtxKMenfUa69zGR0XzfJLy/nlzC9ExkbSvnh7Pi/7Oekd0qdQaiHMR0oWeROAR89MvJJFaz3kP9s4AFuBjVrrqf957a3EAlEBU4BIrfXXLzuvFHmW62bQTZqsa8Igz0F0LNnR6Dj/sshnERO9JrK08VLKZitrdByr9PvF3xl7fCz9K/SnW+luqXLOqLgoWm5oSVx8HH82+xNHO8dUOa94df6h/ng/8CY0OpRYHYtCUSxLMcplLydX4YWwclprtt/azthjYwmKCqJF4RavNDlKaHQoq6+sZumFpTyIeEC13NUY7DlYxt2JNCUlizw3YBXgDtwCPtJaP1ZKeQKfa627KaU6AAsBn2d27aS19lZK7QGyAQrwTtwn9GXnlSLPsrXZ1AatNauarDI6yj+i46JpuLYhBTIVYF6DeUbHsVpaa4YcGMKOWzuYV38elXJWSvFzzjg9gzln5zCn3hzezfVuip9PCCHE63sa+ZTZZ2az6vIqbJQNjfI3ol3xdv9aDiNex+P71JcNvhtYe3UtoTGhvJ3zbbqU7iI/30WalGJFnlGkyLNsyy4uY9zxcaz6IGFtJXOw6vIqRh8dza/1f+Wdt94xOo5VC4sJo+2mtoREh7C6yeoUncr6+tPrtNzYkgYeDRj33rgUO48QQgjT8Av24zef39h4fSMRsRHkcM5BdufsaK25EXyDsJgw7JQdtd1r06VUF0pmlTURRdolRZ4wK0FRQdRZXYdmBZsxvMpwo+MQFRfFB39+QHbn7CxttNRkazmJ57v65Cofb/6YUllL8Wv9X1NkpsTY+Fi6bu/KtaBrrG+2XqZYF0IICxISHcKm65s4H3ieRxGP0GjcM7hTwq0E1fNUl5/pQvDiIk/moBapLlO6TDTwaMDmG5sZ6DnwheskpYbVl1cTEBbA6KqjpcBLJYVdCzO8ynC++esbpp+ezpcVvzT5OSZ5TeLUg1OMqTZGPgwIIYSFyeCQgXbF2hkdQwiLJSPahSFaF2lNWEwYW25sMTRHUFQQc8/OpXLOytJNM5U1LdiU1kVas/D8Qrbd2Gay42qtmek9k6UXl9K+eHuaFmxqsmMLIYQQQlgCKfKEIcpmK0th18KsurwKI7sMTzs1jaDoIIZUGvLyjYXJDa08lPLZy/PtoW85eOdgso8XFRfFVwe/4pczv9CsYDMGeQ4yQUohhBBCCMsiRZ4whFKK9sXac/HxRY7cO2JIBq8AL9ZcWcPHxT5+7XV5hGnY29ozrdY0CmQqQL+9/Vjss5i4+Lg3OlZodCi9dvVi642t9K/Qn9FVR6fIWD8hhBBCCHMnRZ4wTJOCTcjunJ1fz/6a6ud+HPmYrw58hXtGd/qU75Pq5xf/z9XRlXkN5vFurneZ4DWBj7d8zOkHp1/rGIERgXTZ3oVT908x9r2xdCvdTcZXCiGEECLNkiJPGMbB1oFOJTvhdd+L4/eOp9p5w2LC6LenH0+jnjKxxkRc7F1S7dwiaRkdMjKj9gzGvzeewIhAPt36KV8f/JrAiMCX7nvx0UU+3vwxN4NvMr32dD4o8EEqJBZCCCGEMF+yhIIwVGRsJE3XNSVTukyseH8Ftja2KXq+8Jhweu7qyZmHZ5hYYyJ189VN0fOJ1xceE8788/NZeH4hjraO9Cnfh+aFmv8zC2tYTBh+IX7cCbnD4buH+ePqH7g5uvFznZ8p4VbC4PRCCCGEEKlD1skTZm3bjW0MPjCY4e8M56OiH6XYecJjwum1uxfeD7wZX308DTwapNi5RPLdDLrJD8d+4Ni9YwC42LugtSY8NvyfbRxsHGheqDn9KvQjU7pMRkUVQgghhEh1UuQJs6a1pvuO7pwNPMuaJmtwz+hu8nNExEbQZ3cfvO57MbbaWBoXaGzycwjT01pzPOA4Zx+e5XHkY5RSuDm6kSdDHvJmyItHRg/D11kUQgghhDCCFHnC7AWEBdByQ0vyZMjDbw1/w8nOyWTHjouP44t9X7Dfbz9jqo2hScEmJju2EEIIIYQQRnhRkScTrwizkNMlJ2OqjeHio4t889c3bzyNflImek1kn98+vq78tRR4QgghhBDC6kmRJ8xGzbw1Geg5kJ23djLsr2HExMck+5irr6xm6cWldCjegY+Lf2yClEIIIYQQQpi3ZK0UrJTKAqwEPICbwEda6ydJbBcHnEt8eFtr3TTx+fzACsANOAl8orWOTk4mYdk6luxITHwM005NIzw2nAnVJ+Bo5/hGx7r0+BLjjo2jaq6qDPIcZOKkQgghhBBCmKfk3sn7GtittS4M7E58nJQIrXW5xK+mzzw/HpiitS4EPAG6JjOPsALdSndj2NvD2O+3n+47uvMk8n+uG7xUWEwYg/YPInO6zPz43o8pvjSDEEIIIYQQ5iK5RV4zYFHi94uA5q+6o1JKAbWBNW+yv7Bu7Yq1Y2KNiVx4dIFPtn6CX7DfK++rtWbUkVH4hfgxvvp4sjhmScGkQgghhBBCmJfkFnk5tNb3Er8PAHI8ZztHpZSXUuqoUqp54nNuwFOtdWzi4ztA7uedSCnVI/EYXg8fPkxmbGEJ6nvUZ16DeQRFBdF+S3vOPjz7Svv96fsnW25soVfZXnjmTHLCISGEEEIIIazWS4s8pdQupdT5JL6aPbudTliL4XnrMeRLnN7zY2CqUqrg6wbVWs/VWntqrT2zZcv2ursLC1U+e3mWNFqCi70LXbd3Zfet3S/c/vLjy4w9NpZ33nqHbqW7pVJKIYQQQgghzMdLizytdV2tdakkvtYD95VSbwEk/vngOcfwT/zzOrAPKA88AjIrpf6e/CUP4J/sv5GwOh6ZPFjaeClFXIswYN8A5p2bR1LrO/o+8aXHzh5kdMjI2PfGyjg8IYQQQgiRJiW3u+YGoGPi9x2B9f/dQCnlqpRKl/h9VqAqcCHxzt9eoNWL9hcCwM3JjfkN5tPQoyHTTk1jwL4B+IUkjNPTWrPt5jY+2foJtsqW+Q3mk9Upq8GJhRBCCCGEMIZK6o7IK++slBuwCnAHbpGwhMJjpZQn8LnWuptS6l1gDhBPQlE5VWs9P3H/AiQsoZAFOA100FpHvey8np6e2svL641zC8ultWahz0Jme88mMi6SApkKEBMfg1+IH2WyluGnGj+RO/1zh3YKIYQQQghhFZRSJxOHxP3va8kp8owiRZ64H3afDdc2cPbhWWxtbKmWuxrNCjbD3tbe6GhCCCGEEEKkuBcVeclaDF0Io+RwyUH3Mt2NjiGEEEIIIYTZSe6YPCGEEEIIIYQQZkSKPCGEEEIIIYSwIlLkCSGEEEIIIYQVkSJPCCGEEEIIIayIRc6uqZR6SMKSDeYmKxBodAjxUtJO5k/ayDJIO1kGaSfzJ21kGaSdLENaaqd8WutsSb1gkUWeuVJKeT1vGlNhPqSdzJ+0kWWQdrIM0k7mT9rIMkg7WQZppwTSXVMIIYQQQgghrIgUeUIIIYQQQghhRaTIM625RgcQr0TayfxJG1kGaSfLIO1k/qSNLIO0k2WQdkLG5AkhhBBCCCGEVZE7eUIIIYQQQghhRaTIE0IIIYQQQggrIkWeCSilGiqlLiulfJVSXxudRyRNKXVTKXVOKeWtlPIyOo9IoJRaoJR6oJQ6/8xzWZRSO5VSVxP/dDUyo3huO32vlPJPfE95K6UaG5kxrVNK5VVK7VVKXVBK+Sil+ic+L+8nM/KCdpL3k5lQSjkqpY4rpc4kttHIxOfzK6WOJX7eW6mUcjA6a1r2gnb6TSl145n3UjmDoxpCxuQlk1LKFrgC1APuACeAdlrrC4YGE/9DKXUT8NRap5UFMi2CUqo6EAos1lqXSnzuJ+Cx1npc4oUTV631V0bmTOue007fA6Fa64lGZhMJlFJvAW9prU8ppTIAJ4HmQCfk/WQ2XtBOHyHvJ7OglFKAi9Y6VCllD/wF9Ae+BP7QWq9QSv0CnNFazzYya1r2gnb6HNiktV5jaECDyZ285KsM+Gqtr2uto4EVQDODMwlhMbTWB4DH/3m6GbAo8ftFJHwAEgZ6TjsJM6K1vqe1PpX4fQhwEciNvJ/MygvaSZgJnSA08aF94pcGagN/Fw7yXjLYC9pJIEWeKeQG/J55fAf5YW2uNLBDKXVSKdXD6DDihXJore8lfh8A5DAyjHihPkqps4ndOaUboJlQSnkA5YFjyPvJbP2nnUDeT2ZDKWWrlPIGHgA7gWvAU611bOIm8nnPDPy3nbTWf7+XxiS+l6YopdIZl9A4UuSJtKSa1roC0Ajondj9TJg5ndCnXK7MmafZQEGgHHAPmGRoGgGAUio9sBb4Qmsd/Oxr8n4yH0m0k7yfzIjWOk5rXQ7IQ0KvrWLGJhJJ+W87KaVKAUNJaK9KQBYgTXZPlyIv+fyBvM88zpP4nDAzWmv/xD8fAH+S8ENbmKf7ieNW/h6/8sDgPCIJWuv7ib9g44FfkfeU4RLHpawFlmmt/0h8Wt5PZiapdpL3k3nSWj8F9gJVgMxKKbvEl+Tznhl5pp0aJnaJ1lrrKGAhafS9JEVe8p0ACifOuOQAtAU2GJxJ/IdSyiVxgDtKKRegPnD+xXsJA20AOiZ+3xFYb2AW8Rx/Fw6JWiDvKUMlTkIwH7iotZ78zEvyfjIjz2sneT+ZD6VUNqVU5sTvnUiYXO8iCUVEq8TN5L1ksOe006VnLmopEsZNpsn3ksyuaQKJ0xxPBWyBBVrrMcYmEv+llCpAwt07ADvgd2kn86CUWg7UBLIC94ERwDpgFeAO3AI+0lrLpB8Gek471SSha5kGbgKfPTP2S6QypVQ14CBwDohPfHoYCeO95P1kJl7QTu2Q95NZUEqVIWFiFVsSbois0lqPSvwssYKELoCngQ6Jd4uEAV7QTnuAbIACvIHPn5mgJc2QIk8IIYQQQgghrIh01xRCCCGEEEIIKyJFnhBCCCGEEEJYESnyhBBCCCGEEMKKSJEnhBBCCCGEEFZEijwhhBBCCCGEsCJS5AkhhBCAUiqzUqpX4ve5lFJrjM4khBBCvAlZQkEIIYQAlFIewCatdSmjswghhBDJYWd0ACGEEMJMjAMKKqW8gatAca11KaVUJ6A54AIUBiYCDsAnQBTQWGv9WClVEJhJwiK84UB3rfWl1P5LCCGEENJdUwghhEjwNXBNa10OGPyf10oBHwKVgDFAuNa6PHAE+DRxm7lAX611RWAQMCs1QgshhBD/JXfyhBBCiJfbq7UOAUKUUkHAxsTnzwFllFLpgXeB1Uqpv/dJl/oxhRBCCCnyhBBCiFcR9cz38c88jifhd6kN8DTxLqAQQghhKOmuKYQQQiQIATK8yY5a62DghlKqNYBKUNaU4YQQQohXJUWeEEIIAWitHwGHlFLngQlvcIj2QFel1BnAB2hmynxCCCHEq5IlFIQQQgghhBDCisidPCGEEEIIIYSwIlLkCSGEEEIIIYQVkSJPCCGEEEIIIayIFHlCCCGEEEIIYUWkyBNCCCGEEEIIKyJFnhBCCCGEEEJYESnyhBBCCCGEEMKK/B/RdSzIZ8p53AAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "rk_solu.plot(figsize=(15,8), subplots=True, title=\"Runge-Kutta\") " - ] - }, - { - "cell_type": "markdown", - "id": "120841b3", - "metadata": {}, - "source": [ - "### PINN solution" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "id": "7db42f4e", - "metadata": {}, - "outputs": [], - "source": [ - "T = tp.spaces.R1('t') # time\n", - "# Output\n", - "U = tp.spaces.R1('u')\n", - "# Intervals and domains and sampler\n", - "Dmin, Dmax = 0.01, 0.1\n", - "A_t = tp.domains.Interval(T, 0, t_end)\n", - "inner_sampler = tp.samplers.GridSampler(A_t, n_points = 2048)#.make_static()\n", - " \n", - "initial_u_sampler = tp.samplers.GridSampler(A_t.boundary_left, n_points = 1).make_static()\n", - "initial_v_sampler = tp.samplers.GridSampler(A_t.boundary_left, n_points = 1).make_static()" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "id": "6e78c8d5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 68, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "_eval = \"wn\"\n", - "f, ax = plt.subplots(figsize=(15,8))\n", - "F[_eval].plot(title=\"Right hand site f(t)\", ax=ax)\n", - "F_inter_func = func_f[_eval]\n", - "pd.DataFrame(F_inter_func(inner_sampler.sample_points().as_tensor.numpy().ravel()),\n", - " index=pd.Index(inner_sampler.sample_points().as_tensor.numpy().ravel(),name=\"time\"),\n", - " columns=[\"sample points for PINN\"]).plot(\n", - " # x=\"time\", y=\"sample points for PINN\",\n", - " marker=\"o\",\n", - " color=\"r\",\n", - " linestyle=None,\n", - " linewidth=0.1,\n", - " ax=ax\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "id": "1eb8838f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "=================================================================\n", - "Layer (type:depth-idx) Param #\n", - "=================================================================\n", - "FCN --\n", - "├─Sequential: 1-1 --\n", - "│ └─Linear: 2-1 64\n", - "│ └─DampedSine: 2-2 --\n", - "│ └─Linear: 2-3 1,056\n", - "│ └─DampedSine: 2-4 --\n", - "│ └─Linear: 2-5 528\n", - "│ └─DampedSine: 2-6 --\n", - "│ └─Linear: 2-7 102\n", - "│ └─DampedSine: 2-8 --\n", - "│ └─Linear: 2-9 28\n", - "│ └─DampedSine: 2-10 --\n", - "│ └─Linear: 2-11 5\n", - "=================================================================\n", - "Total params: 1,783\n", - "Trainable params: 1,783\n", - "Non-trainable params: 0\n", - "=================================================================" - ] - }, - "execution_count": 69, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#%% Model Definition\n", - "class Snake(torch.nn.Module):\n", - " def __init__(self):\n", - " super().__init__()\n", - " pass\n", - "\n", - " def forward(self, Tensor):\n", - " a = 1\n", - " return Tensor + (1.0/a) * torch.pow(torch.sin(Tensor * a), 2)\n", - "\n", - "class Sine(nn.Module):\n", - " def __init__(self):\n", - " super().__init__()\n", - " pass\n", - "\n", - " def forward(self, Tensor):\n", - " return torch.sin(Tensor)\n", - " \n", - "class DampedSine(nn.Module):\n", - " def __init__(self):\n", - " super().__init__()\n", - " pass\n", - "\n", - " def forward(self, Tensor):\n", - " alpha = 0.1\n", - " return torch.exp(-alpha * Tensor) * torch.sin(Tensor)\n", - "\n", - "model = tp.models.FCN(input_space=T, output_space=U, hidden=(32, 32, 16, 6, 4),\n", - " activations=DampedSine() #Tanh(), RNN()\n", - "# activations=[Snake(), Snake(), Snake()] #Tanh(), RNN()\n", - " \n", - " )\n", - "\n", - "\n", - "# model = tp.models.Sequential(\n", - "# tp.models.NormalizationLayer(A_t),\n", - "# tp.models.FCN(input_space=T, output_space=U, hidden=(32,32, 16),\n", - "# activations=Sine())\n", - "# )\n", - "model \n", - "summary(model, input_size=None)" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "id": "d7626839", - "metadata": {}, - "outputs": [], - "source": [ - "def right_hand_side(t):\n", - " rhs = f_fac * torch.tensor(F_inter_func(t.detach().cpu().numpy()))\n", - " return rhs.cuda()\n", - "\n", - "def duffing_residual(u, t, right_hand_side):\n", - " pde_homo = tp.utils.laplacian(u, t) + 2 * ode_params[\"D\"] * tp.utils.grad(u, t) \\\n", - " + u + ode_params[\"c_nlin\"] * u**3 #- right_hand_side(t)\n", - " return pde_homo - right_hand_side \n", - " \n", - "pde_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=inner_sampler,\n", - " residual_fn=duffing_residual,\n", - " data_functions={'right_hand_side': right_hand_side},\n", - " name='pde_condition',\n", - " weight=10.0)\n", - "\n", - "def initial_u_residual(u):\n", - " return u - x0[0]\n", - "initial_u_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=initial_u_sampler,\n", - " residual_fn=initial_u_residual,\n", - " name='ic_u')\n", - "\n", - "def initial_v_residual(u, t):\n", - " return tp.utils.grad(u, t) - x0[1]\n", - "initial_v_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=initial_v_sampler,\n", - " residual_fn=initial_v_residual,\n", - " name='ic_v')\n", - "def rhs_residual(u, right_hand_side):\n", - " return right_hand_side - u\n", - "\n", - "rhs_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=inner_sampler,\n", - " residual_fn=rhs_residual,\n", - " data_functions={'right_hand_side': right_hand_side},\n", - " name='rhs',\n", - " weight=12)" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "id": "3dd9b6e3", - "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: [MIG-GPU-bf355ce4-05d3-bb64-9bee-4f04b006a8ae/5/0]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 1.8 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "1.8 K Trainable params\n", - "0 Non-trainable params\n", - "1.8 K Total params\n", - "0.007 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "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/krd2rng/.conda/envs/pytorch-physics/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 64 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n", - "/home/krd2rng/.conda/envs/pytorch-physics/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 64 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": "a94ab37a68454167a28c8c572f6d38cb", - "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": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "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: [MIG-GPU-bf355ce4-05d3-bb64-9bee-4f04b006a8ae/5/0]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 1.8 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "1.8 K Trainable params\n", - "0 Non-trainable params\n", - "1.8 K Total params\n", - "0.007 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "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": "a154da0d64094719ba97bf6648771bce", - "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": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "gpus_switch = 1 if torch.cuda.is_available() else None\n", - "gpus_switch\n", - "#%% Training\n", - "for opti, steps in zip([torch.optim.AdamW, torch.optim.LBFGS], [5000, 240]):\n", - " opt_setting = tp.solver.OptimizerSetting(opti, lr=1e-2) #AdamW, SGD, LBFGS\n", - " solver = tp.solver.Solver([pde_condition,\n", - " initial_u_condition,\n", - " initial_v_condition,\n", - "# rhs_condition\n", - " ], optimizer_setting = opt_setting)\n", - " \n", - " trainer = pl.Trainer(gpus=gpus_switch,\n", - " max_steps = steps,\n", - " logger=True, \n", - " benchmark=False,\n", - " log_every_n_steps=10,\n", - " )\n", - " trainer.fit(solver)" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "id": "b4eb90d6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#%% Prediction\n", - "time_tensor = torch.tensor(time)\n", - "\n", - "grid_sampler = tp.samplers.GridSampler(A_t, n_points=len(rk_solu)) #+ tp.samplers.GridSampler(A_t.boundary, n_points=1)\n", - "grid_points = grid_sampler.sample_points()\n", - " # )\n", - "model_out = model(grid_points)\n", - "pinn_solu = pd.Series(np.interp(rk_solu.index, grid_points.as_tensor.detach().numpy().ravel(), \n", - " model_out.as_tensor.detach().numpy().ravel()),\n", - " index=rk_solu.index, name=\"PINN\"\n", - " )\n", - "solu_comb = pd.concat((rk_solu[_eval], pinn_solu), axis=1)\n", - "solu_comb.plot(marker=\"x\", figsize=(15,8))" - ] - }, - { - "cell_type": "markdown", - "id": "b65d386b", - "metadata": {}, - "source": [ - "### Some validation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "533faea6", - "metadata": {}, - "outputs": [], - "source": [ - "time_val = np.linspace(0, 2 * t_end, t_end*sampling_frequency + 1)\n", - "F = pd.DataFrame([np.random.randn(time.shape[0]),\n", - " columns=pd.Index(time, name=\"time\"),\n", - " index=[\"wn\", \"SineSweep\", \"SoR\"]\n", - " ).T" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "22156ceb", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:.conda-pytorch-physics]", - "language": "python", - "name": "conda-env-.conda-pytorch-physics-py" - }, - "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.6" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/pinn/.ipynb_checkpoints/heat-equation-checkpoint.ipynb b/examples/pinn/.ipynb_checkpoints/heat-equation-checkpoint.ipynb deleted file mode 100644 index 8126dc10..00000000 --- a/examples/pinn/.ipynb_checkpoints/heat-equation-checkpoint.ipynb +++ /dev/null @@ -1,405 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# PINN: Heat equation with variable diffusion\n", - "Solving the heat equation in 2D for variable diffusion D using the PINN-concept." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torchphysics as tp\n", - "import math" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we create the spaces for our problem. These define the variable names which will be used in the remaining part of this code.\n", - "\n", - "In this example, x is the space variable, t corresponds to the time, D is an interval of diffusions and u is the variable for the (1D-)solution." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "X = tp.spaces.R2('x')\n", - "T = tp.spaces.R1('t')\n", - "D = tp.spaces.R1('D')\n", - "\n", - "U = tp.spaces.R1('u')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As a next step, we build the domain of the problem. There are multiple options to build multi-dimensional domains - in this case, we simply create a rectangle in space and intervals in time and diffusion which will later be multiplied to obtain the cartesian product." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "h, w = 20, 20" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "A_x = tp.domains.Parallelogram(X, [0, 0], [w, 0], [0, h])\n", - "A_t = tp.domains.Interval(T, 0, 40)\n", - "A_D = tp.domains.Interval(D, 0.1, 1.0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Before we visualize the created domain, we create Sampler objects which are iterators that sample points from the domain during the optimization task. There are again various options to sample from the domains, an easy way would be to sample uniformly distributed random points. In this example, we choose an adaptive sampler to sample points in the inner of the domain. It will sample more points in points where the loss is large.\n", - "\n", - "The amount of sampled points is defined by their density in the 3/2-dim subset, it could be increased to achieve better training results." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "inner_sampler = tp.samplers.AdaptiveRejectionSampler(A_x*A_t*A_D, density=1)\n", - "# initial values should be sampled on the left boundary of the time interval and for every x and D\n", - "initial_v_sampler = tp.samplers.RandomUniformSampler(A_x*A_t.boundary_left*A_D, density=1)\n", - "\n", - "boundary_v_sampler = tp.samplers.RandomUniformSampler(A_x.boundary*A_t*A_D, density=1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We visualize the domain through the points created by the samplers using matplotlib:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "tp.utils.scatter(X*T, inner_sampler, initial_v_sampler, boundary_v_sampler)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the next step we define the NN-model we want to fit to the PDE. A normalization can improve convergence for large or small domains." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "model = tp.models.Sequential(\n", - " tp.models.NormalizationLayer(A_x*A_t*A_D),\n", - " tp.models.FCN(input_space=X*T*D, output_space=U, hidden=(50,50,50))\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now, we define a condition which aims to minimze the mean squared error of the residual of the poisson equation. " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "def heat_residual(u, x, t, D):\n", - " return D*tp.utils.laplacian(u, x) - tp.utils.grad(u, t)\n", - "\n", - "pde_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=inner_sampler,\n", - " residual_fn=heat_residual,\n", - " name='pde_condition')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Additionally, we add a boundary condition at the boundary of the domain:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def boundary_v_residual(u):\n", - " return u\n", - "\n", - "boundary_v_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=boundary_v_sampler,\n", - " residual_fn=boundary_v_residual,\n", - " name='boundary_condition')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The initial condition can be defined via a data function. Again, we minimize the mean squared error over the sampled points." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def f(x):\n", - " return torch.sin(math.pi/w*x[:, :1])*torch.sin(math.pi/h*x[:,1:])\n", - "\n", - "def initial_v_residual(u, f):\n", - " return u-f\n", - "\n", - "initial_v_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=initial_v_sampler,\n", - " residual_fn=initial_v_residual,\n", - " data_functions={'f': f},\n", - " name='initial_condition')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For comparison, we compute the solution via a finite difference scheme." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "sys.path.append('..')\n", - "\n", - "from fdm_heat_equation import FDM, transform_to_points\n", - "\n", - "fdm_domain, fdm_time_domains, fdm_solution = FDM([0, w, 0, h], 2*[2e-1], [0,5], [1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0], f)\n", - "fdm_inp, fdm_out = transform_to_points(fdm_domain, fdm_time_domains, fdm_solution, [1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0], True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Comparsion to measured or computed data can be performed via a DataCondition using data supplied via a PointsDataLoader." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "val_condition = tp.conditions.DataCondition(module=model,\n", - " dataloader=tp.utils.PointsDataLoader((fdm_inp, fdm_out), batch_size=80000),\n", - " norm='inf')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, we optimize the conditions using a pytorch-lightning.LightningModule Solver and running the training. In the Solver, the training and validation conditions, as well as all optimizer options can be specified." - ] - }, - { - "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: [0]\n", - "/home/krd2rng/.conda/envs/pytorch-physics/lib/python3.9/site-packages/torch/cuda/__init__.py:106: UserWarning: \n", - "A40 with CUDA capability sm_86 is not compatible with the current PyTorch installation.\n", - "The current PyTorch install supports CUDA capabilities sm_37 sm_50 sm_60 sm_70.\n", - "If you want to use the A40 GPU with PyTorch, please check the instructions at https://pytorch.org/get-started/locally/\n", - "\n", - " warnings.warn(incompatible_device_warn.format(device_name, capability, \" \".join(arch_list), device_name))\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 5.4 K \n", - "1 | val_conditions | ModuleList | 5.4 K \n", - "------------------------------------------------\n", - "5.4 K Trainable params\n", - "0 Non-trainable params\n", - "5.4 K Total params\n", - "0.022 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f15271b9e1264ce0bae3a4be46122ff7", - "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/krd2rng/.conda/envs/pytorch-physics/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 128 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n" - ] - }, - { - "ename": "RuntimeError", - "evalue": "CUDA error: no kernel image is available for execution on the device\nCUDA kernel errors might be asynchronously reported at some other API call,so the stacktrace below might be incorrect.\nFor debugging consider passing CUDA_LAUNCH_BLOCKING=1.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0mval_check_interval\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m400\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m checkpoint_callback=False)\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mtrainer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msolver\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, model, train_dataloader, val_dataloaders, datamodule)\u001b[0m\n\u001b[1;32m 456\u001b[0m )\n\u001b[1;32m 457\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 458\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 459\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 460\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstopped\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, model)\u001b[0m\n\u001b[1;32m 754\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 755\u001b[0m \u001b[0;31m# dispatch `start_training` or `start_evaluating` or `start_predicting`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 756\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdispatch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 757\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 758\u001b[0m \u001b[0;31m# plugin will finalized fitting (e.g. ddp_spawn will load trained model)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py\u001b[0m in \u001b[0;36mdispatch\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 795\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maccelerator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_predicting\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 796\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 797\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maccelerator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_training\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 798\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 799\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mrun_stage\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/pytorch_lightning/accelerators/accelerator.py\u001b[0m in \u001b[0;36mstart_training\u001b[0;34m(self, trainer)\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mstart_training\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrainer\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'pl.Trainer'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 96\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtraining_type_plugin\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_training\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrainer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 97\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 98\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mstart_evaluating\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrainer\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'pl.Trainer'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/pytorch_lightning/plugins/training_type/training_type_plugin.py\u001b[0m in \u001b[0;36mstart_training\u001b[0;34m(self, trainer)\u001b[0m\n\u001b[1;32m 142\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mstart_training\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrainer\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'pl.Trainer'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 143\u001b[0m \u001b[0;31m# double dispatch to initiate the training loop\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 144\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_results\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrainer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_stage\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 145\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 146\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mstart_evaluating\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrainer\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'pl.Trainer'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py\u001b[0m in \u001b[0;36mrun_stage\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 805\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredicting\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 806\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_predict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 807\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 808\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 809\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_pre_training_routine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py\u001b[0m in \u001b[0;36mrun_train\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 840\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprogress_bar_callback\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdisable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 841\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 842\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_sanity_check\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlightning_module\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 843\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 844\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcheckpoint_connector\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhas_trained\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py\u001b[0m in \u001b[0;36mrun_sanity_check\u001b[0;34m(self, ref_model)\u001b[0m\n\u001b[1;32m 1105\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1106\u001b[0m \u001b[0;31m# run eval step\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1107\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_evaluation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1108\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1109\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_sanity_check_end\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py\u001b[0m in \u001b[0;36mrun_evaluation\u001b[0;34m(self, on_epoch)\u001b[0m\n\u001b[1;32m 960\u001b[0m \u001b[0;31m# lightning module methods\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 961\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprofiler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprofile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"evaluation_step_and_end\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 962\u001b[0;31m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluation_loop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluation_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdataloader_idx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 963\u001b[0m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluation_loop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluation_step_end\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 964\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/pytorch_lightning/trainer/evaluation_loop.py\u001b[0m in \u001b[0;36mevaluation_step\u001b[0;34m(self, batch, batch_idx, dataloader_idx)\u001b[0m\n\u001b[1;32m 172\u001b[0m \u001b[0mmodel_ref\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_current_fx_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"validation_step\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrainer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprofiler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprofile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"validation_step\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 174\u001b[0;31m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrainer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maccelerator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalidation_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 175\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 176\u001b[0m \u001b[0;31m# capture any logged information\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/pytorch_lightning/accelerators/accelerator.py\u001b[0m in \u001b[0;36mvalidation_step\u001b[0;34m(self, args)\u001b[0m\n\u001b[1;32m 224\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 225\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprecision_plugin\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mval_step_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtraining_type_plugin\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mval_step_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 226\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtraining_type_plugin\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalidation_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 227\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 228\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mAny\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mSTEP_OUTPUT\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/pytorch_lightning/plugins/training_type/training_type_plugin.py\u001b[0m in \u001b[0;36mvalidation_step\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 159\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 160\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mvalidation_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 161\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlightning_module\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalidation_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 162\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 163\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/python/mso-036/src/torchphysics/solver.py\u001b[0m in \u001b[0;36mvalidation_step\u001b[0;34m(self, batch, batch_idx)\u001b[0m\n\u001b[1;32m 85\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mcondition\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mval_conditions\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 86\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_grad_enabled\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcondition\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrack_gradients\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 87\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'val/{condition.name}'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcondition\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweight\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mcondition\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 88\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 89\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mconfigure_optimizers\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1049\u001b[0m if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[1;32m 1050\u001b[0m or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1051\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1052\u001b[0m \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1053\u001b[0m \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/python/mso-036/src/torchphysics/problem/conditions/condition.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, device)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miterator\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0miter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataloader\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0mbatch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compute_dist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 136\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnorm\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'inf'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/python/mso-036/src/torchphysics/problem/conditions/condition.py\u001b[0m in \u001b[0;36m_compute_dist\u001b[0;34m(self, batch, device)\u001b[0m\n\u001b[1;32m 116\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 118\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodule\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_tensor\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_tensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 119\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'cpu'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1049\u001b[0m if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[1;32m 1050\u001b[0m or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1051\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1052\u001b[0m \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1053\u001b[0m \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/python/mso-036/src/torchphysics/models/model.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, points)\u001b[0m\n\u001b[1;32m 102\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpoints\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 104\u001b[0;31m \u001b[0mpoints\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpoints\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 105\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mpoints\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 106\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1049\u001b[0m if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[1;32m 1050\u001b[0m or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1051\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1052\u001b[0m \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1053\u001b[0m \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/python/mso-036/src/torchphysics/models/model.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, points)\u001b[0m\n\u001b[1;32m 54\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 55\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpoints\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 56\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mPoints\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormalize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpoints\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutput_space\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 57\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 58\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1049\u001b[0m if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[1;32m 1050\u001b[0m or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1051\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1052\u001b[0m \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1053\u001b[0m \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/torch/nn/modules/linear.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 96\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinear\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbias\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 97\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 98\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mextra_repr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/torch/nn/functional.py\u001b[0m in \u001b[0;36mlinear\u001b[0;34m(input, weight, bias)\u001b[0m\n\u001b[1;32m 1844\u001b[0m \"\"\"\n\u001b[1;32m 1845\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mhas_torch_function_variadic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1846\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mhandle_torch_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlinear\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbias\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbias\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1847\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_C\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_nn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinear\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbias\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1848\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/torch/overrides.py\u001b[0m in \u001b[0;36mhandle_torch_function\u001b[0;34m(public_api, relevant_args, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1250\u001b[0m \u001b[0;31m# Use `public_api` instead of `implementation` so __torch_function__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1251\u001b[0m \u001b[0;31m# implementations can do equality/identity comparisons.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1252\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moverloaded_arg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__torch_function__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpublic_api\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtypes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1253\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1254\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mNotImplemented\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/python/mso-036/src/torchphysics/problem/spaces/points.py\u001b[0m in \u001b[0;36m__torch_function__\u001b[0;34m(cls, func, types, args, kwargs)\u001b[0m\n\u001b[1;32m 272\u001b[0m \u001b[0mspaces\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mspace\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0margs\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'space'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 273\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mspaces\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 274\u001b[0;31m \u001b[0mret\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 275\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mret\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 276\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda/envs/pytorch-physics/lib/python3.9/site-packages/torch/nn/functional.py\u001b[0m in \u001b[0;36mlinear\u001b[0;34m(input, weight, bias)\u001b[0m\n\u001b[1;32m 1845\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mhas_torch_function_variadic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1846\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mhandle_torch_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlinear\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbias\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbias\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1847\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_C\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_nn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinear\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbias\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1848\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1849\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mRuntimeError\u001b[0m: CUDA error: no kernel image is available for execution on the device\nCUDA kernel errors might be asynchronously reported at some other API call,so the stacktrace below might be incorrect.\nFor debugging consider passing CUDA_LAUNCH_BLOCKING=1." - ] - } - ], - "source": [ - "solver = tp.solver.Solver([pde_condition,\n", - " boundary_v_condition,\n", - " initial_v_condition], [val_condition])\n", - "\n", - "import pytorch_lightning as pl\n", - "\n", - "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n", - "\n", - "trainer = pl.Trainer(gpus=1, # or None for CPU\n", - " max_steps=2000,\n", - " logger=False,\n", - " benchmark=True,\n", - " val_check_interval=400,\n", - " checkpoint_callback=False)\n", - "trainer.fit(solver)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, we plot the obtained solution:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "anim_sampler = tp.samplers.AnimationSampler(A_x, A_t, 100, n_points=400, data_for_other_variables={'D': 1.0})\n", - "anim = tp.utils.animate(model, lambda u: u[:, 0], anim_sampler, ani_speed=10)\n" - ] - } - ], - "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.6" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/oscillation/duffing_nonlinear.ipynb b/examples/pinn/duffing_nonlinear.ipynb similarity index 100% rename from examples/oscillation/duffing_nonlinear.ipynb rename to examples/pinn/duffing_nonlinear.ipynb diff --git a/examples/pinn/heat-equation.ipynb b/examples/pinn/heat-equation.ipynb index ad130cae..9e5a0b89 100644 --- a/examples/pinn/heat-equation.ipynb +++ b/examples/pinn/heat-equation.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -422,7 +422,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "tp_version2", "language": "python", "name": "python3" }, diff --git a/examples/solid_mechanics/.ipynb_checkpoints/mechanic_cube_FCN-checkpoint.ipynb b/examples/solid_mechanics/.ipynb_checkpoints/mechanic_cube_FCN-checkpoint.ipynb deleted file mode 100644 index 1c24c7b4..00000000 --- a/examples/solid_mechanics/.ipynb_checkpoints/mechanic_cube_FCN-checkpoint.ipynb +++ /dev/null @@ -1,784 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torchphysics as tp\n", - "import pytorch_lightning as pl\n", - "import itertools\n", - "import math\n", - "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"3\"" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "# Spaces for in- and output\n", - "X = tp.spaces.R1('x')\n", - "Y = tp.spaces.R1('y')\n", - "Z = tp.spaces.R1('z')\n", - "U = tp.spaces.R3('u')\n", - "\n", - "# Parameter\n", - "fskal =18333\n", - "kappa = 18333.3/fskal # GPa = 18333,33 Mpa\n", - "mu = 3928.57/fskal # GPa = 3928.57 Mpa\n", - "u_dis = 0.2 # mm\n", - "size = 5.0 # mm" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "# Load stl.file and create domain\n", - "Ix = tp.domains.Interval(X, -size, size)\n", - "Iy = tp.domains.Interval(Y, -size, size)\n", - "Iz = tp.domains.Interval(Z, -size, size)\n", - "cube = Ix * Iy * Iz" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "class Sinus(torch.nn.Module):\n", - " def __init__(self):\n", - " super().__init__()\n", - "\n", - " def forward(self, input):\n", - " return torch.sin(input)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "# network to train\n", - "model = tp.models.Sequential(\n", - " tp.models.NormalizationLayer(cube),\n", - " #tp.models.FCN(activations = Sinus(),input_space=X*Y*Z, output_space=U, hidden=(30,30,30,30,30)))\n", - " #tp.models.FCN(input_space=X*Y*Z, output_space=U, hidden=(32,32,32,32,32))) \n", - " tp.models.FCN(input_space=X*Y*Z, output_space=U, hidden=(50,50,50),xavier_gains=[5/3,5/3,0]))" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "inner_sampler = tp.samplers.RandomUniformSampler(cube, n_points = 1000) #.make_static()\n", - "\n", - "fig = tp.utils.scatter(X*Y*Z, inner_sampler)\n", - "fig.get_axes()[0].view_init(30, 170)\n", - "fig.set_size_inches(6, 4)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPcAAAD1CAYAAACMRGNYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAB2HklEQVR4nO2deXxcZ3X3v3eZfTTad3mV93iL46wE4iQkEJawNJSdtmyFFkootLQvTctSCKXkbcMLLX3LS8sOLQVCFkIIWUhiO7aTOI73TdaukWbf79zt/ePqjmdGI1mSJdsS8/t89JHmaua5d2bueZ7znPM7vyOYpkkVVVSx+CBe7Auooooq5gdV466iikWKqnFXUcUiRdW4q6hikaJq3FVUsUhRNe4qqlikkOdx7GqOrYoq5h/CZP+ortxVVLFIUTXuKqpYpKgadxVVLFJUjbuKKhYpqsZdRRWLFFXjrqKKRYqqcVdRxSJF1birqGKRomrcVVSxSFE17iqqWKSoGncVVSxSVI27iioWKarGXUUVixRV466iikWKqnFXUcUiRdW4q6hikaJq3FVUsUhRNe4qqlikqBp3FVUsUlSNu4oqFimqxl1FFYsU86l+uqhhGAaKoiDLMoIgIAiWCOVkv6uo4kKjatyzRD6fJ5vN4vF4pnxesZGXTwLVCaGK+UTVuGcB0zTJ5XKYpokoTr6zKW6PbJpm4acYiqLQ19fH6tWrC8eqE0IVc4Gqcc8C+Xx+gpFWQiWDKz8mCAKpVKowSUxnQpjqXOUTgj1upUmgOiEsblSNe4awV21RFDEM47zHEwShxHinMyFUuqbiv4snhL6+PlwuF62trZOOW50QFieqxj1D5PN5DMNAFEVM0yz8PVvY45wPppoQbEMvv8byCWG6E1X5hGC/f0mSJvx/smur4sKgatwzgL1qS5I0ZzetbSDzhXLPoPj4VI8rodKEcODAAbq7u/H5fBXPV27kxV5BNX4wv6ga9wxgr9qybH1sc3ETTmZ8lyImmxAEQSjxDIq9Bhv235qmTfs8giAUMhKiKFYnhBmiatzTRPFeey5xIYx7vsefzLDmIn5w+PBh1q9fj9vtntY1TJZh+F2MH1SNe5qIxWJks1lqamrmdNz5Nu6FdgOXX69pmkiSdN4px8nOlUgk8Hg8uFyuRRdQrBr3NGCaJmNjYyiKMsG45yMYtpBgmua8vofpjH8+HkJ/fz9dXV04HI45SzkWH7+YqBr3NJDP5+ckqn0xsJD29JUwX5OHPaZhGIUA6Uy3DJMFQiVJwul0zt3FzhJV4z4H5jqvXcXMMN+egWEY0x5/uhmGuY7LzBaXxlVcwrDZaJIkLUjjnu+V+0IY33way7koxAsZ1ZV7CpimiaIohVRPuZGcOHGCTCaDw+HA4XDgdDpxOp0lfxcfs4keVUwfC33yuJioGvcUUFW1sCcrd8uTyST5fJ6rrrqq8Nx8Pl/4URSl8Bz7x54cBEEomQAURaG/v3/C5OBwOM77xp5vkox9joU6/nwY96UQTIOqcU8Ke69dHA0tNpIzZ86wdOlSBEFAlmUcDgder3daYxuGUTIZBINBTNMsmQxUVUVV1cJr7CBNJc+g+PGF9g4WcrAOQNf1RetRVY17Eqiqiq7rBTZasXGn02k0TSMQCMxqbFEUcblcuFwuABwOB0uXLp30+aZpout6ieEXewfFE4V9jbZ3oGkagiCgaVrFyWAuvIOFjKpb/juGSmy0Yve2t7eXZcuWFZ4737C9A1mWZ+wdDAwMoCgKPp+PfD4/YTKwvQPTNJFl+ZyegcPhKEx4iwWLdXJbXN/SHKF81Yaz1VvZbJZsNkt9ff20eNIXC7Z34PF4kCSJtra2KZ9f7B0UG7+iKKRSqZLJQNf1wuuy2SxHjhzB7XZPOTEsVgOqhEvlvVaNuwymadLT00NjY+ME49Z1vbBqVyqOON/zztdNMV3mle0dzGTcvXv3FrwY2/jT6TTRaLRkorAhiuI5swp27OBSMZKFiqpxl0HTNEKhEPX19SXHbeNOpVKsXbt2Ts9p56IX2s1ss7r8fv+0GVnFsYNi40+n0yWPbe8glUqxd+/eaW0XFuveebaoGncRpmKjiaJILpdj7dq1c26E80k0udTop5Ik4fF4ziksaeOZZ55hy5YtE7YL5ZOBqqqF92l7B+fiHizWKLmNqnEXQdO0Qmqk3LjtvWZzc/Ocn/dSM8BLCYIgFIxxutB1fQLvwFarLX5se2I7d+48JxHJfjwd7+BS8cCqxj2O4rx2pZXbJpnMVxHDQl25L8XthCRJSJJ0zhpwgJ07d3LttdeiadqE7UI2myUej5d4CMVEpMm2CB0dHZeEV1A17nHYq7YoihOMW1VVwuFwxS9sLgxnoVacLXTYRSM2J8DhcBTkoqbz2kqxg3g8Tnt7+zxf+fRQNW5KV+1KK/fAwACdnZ0MDg5WfO35Yj4povO9ql6KK/d0cT4EFlEUcbvdFb2DS2HVhmpVGHB21a5ENdU0jbGxMdrb2+ftJr4QrvNCxHxf93yx0y6Vye533rjLV204m/YCGBoaoq2tbV7TLPO9516oqFaEnR8W7zubJspXbTi7cuu6zvDwMJ2dnYX/latxRKNREokEuVxu1q71fAtBXCyBxPPFQjTuS2ky/Z3ec1dateFsgGt4eJjW1tYSwf3iG66/v590Oo3L5ZpQ1lkp11rpx2ZiVV3nymPP58o6ExWWhYjfaePOZrNEo1Hq6upKjouiiKqqjIyMsG3btsJxO/Blu+2hUIht27ZVjLCei4lVXMWVzWZJJBIFfvZklEyn01loGTxdLOSJY76Nz1bYWaz4nTVu26UeGRmZQDWVJIlQKERTU1PF4hGw9uKtra2TriwzYWIdPHiQzs5OvF7vBOKFnWctJl7YmIqOaf9cCE30heqW26nPxYrfWePWdX1SBUtBEIjH4xM45Pbe2DAMhoeH2bJly5zluYGSGu9zwTTNiiys4qINm5Vl8+WLBR8m+7mUONrVPff54XfSuO29tizLFY0zkUjgcrkmUB5t4w4Gg4WqsbnKc890nOnSMkOhEOFwmDVr1qBp2oQJoZiFNRlHe6ptwkJmvy32aPnvpHHb3GNJkkrcXDjbgKC2tnbC6+y99sDAAFu2bCk8/3xxIVJhxSys6Qo+lMcNKqm/pNNpdu/eXTjHTIKI58KFCKhVjXsRoThCXqlAJBQK4fP5Kn7poigSiUQIBAI4nc4JE8NscamSWKYTN7C52XawsXwymKxgw8ZUE4HtRczXCl417kUGXdfRNK3wpRYbt2ma9PX1sXz5coLB4ITXCoLAyMgImzZtKjyeCyyWPPdUlMxKmCxuYAtFZjIZEokEu3btKrzGloKaKpA43bhBdc+9iGCv2nC27WyxUUWj0cJKVcnYVFXF4XBMuxZ5uvhdZaidK26QSCTo7e0tTKamaU6o3rIngVgsVjJR2LCDiJU8hHQ6XZLeXGz4nTLu8lW7/MY/c+YMa9eunXQlTSaTE1RKL/U990JGuTs+m+otezIo14VLJpNEo9FC7cBkpZyTeQkLQSTy0r/COUTxql2OWCyG0+ksqISWG3cymUQQhGm7nDPBfJZ8LuSJYy4CalPpwp05cwaHw1FCL54sbjCZDBRQYvgdHR20tLSc1zXPFX5njFvTtJJVuxy9vb10d3cDlffAvb291NfXz8ve+EJ0BVmIuBipsJnGDcobTMzH5D9b/M4Y91SrdiKRKAj9wUTjzmQy5PN5AoHAvBl3deWeiPmmn87FXru8wcSl5K4vvihCBei6zpEjR6ZctW15XphoEP39/SxdunTeotoL2QDnE1USy/lh8b6zItiFGZVuFDvIVkxaKX6eoigkEgkaGxsrus9TNWGfLqp77sqoGvf54dLxIeYJNhttMqiqyurVqyf9/8DAAEuWLCmkzsq7jBw4cABgSt62y+WaUj2zuueujIVo3JdS6nHRG3elem0bmUwG0zSpqamp+FpN0wiHw6xYsQIoVWgBCAaD1NXVsX79ekzTnJSqqSjKBPXM4slAURSAAp99Los4LqWbbaao0k/PD4vauG1utF2zW74S9Pb24vF4JnVbBwYG6OjoKNwAxe6zaZoMDAywYcMGYOZi+8VkjGAwSCaTmbKIYzoVXZNJL1fd8sqoGvcCRvGqXa6iksvlCioqlVxi0zQJBoNs3769cKw4oBYOhwkEAjgcjlldW3HXzlwuhyRJLFm2HIc08WYrb+E7WUVXJWaWIAik02n6+voK3oDtIVzq7XsXQrT8UsaiNW57r21/eXYFmP24r6+PpUuXEgqFKhaAqKo6QVy+2Lj7+/sL9d6zXRkj6TzP98U4PhBhOJpibchJW62ba1c24HOd/Wpm2sK3eDKwa7ttIy9Xh7FRibNdiZ11ISeDhbhyX0qT5aI1bnsfW0mu2FY4Wb16NZFIZMLKbRMTOjo6So7bYyQSiYKhFa+Wk0HVDUwTnPLZGymT13ns2BiGYXImkiOdU0nlNaIZlZ2nItyyoZTllMppZFUdv0vG45xaGqh4MtB1nXA4zJIlSyZ9/mSc7XLhh0qTQTab5eTJk/MyGSxE476UsCiN2161ir+44trtvr6+kgh4uXGPjY3hcDgm6GvZz7VX/XPBNE3298d5aShBVtVp9jvZvrSOrnovsYyKqhtIokA8p6GpJkdHUrx2o4+xlIKqGwUX/dhIkj1noggCiILAzeuaaQ24C+eYygCmkwqbKWe7eDJIJBLU1NSUTAZ2ALF4MrDHLw8aFv+U68NVjfv8sCiNu3zVhrOGqaoqkUiElStXlhy3YZom/f39FSvDBEEo8IoriTkUQ9MNDgwk2N0TIeCWOBPK8GJ/nMMjKV7e3ciaVj+abnJqLE0orSGhk00qHBpO0lnn4fBQgkhGxeOQODqSpDXgQpZEsnmd3x4PcVlHgOf7Y+gGbO4KsKWzFlG8MC5hTjVQNPC53IzmBOSUTI3bzdplNSXeiY1zlXbaP8VpRofDUajCU1V1WpPBTFE17gWGSqs2nDViuzVQcQS82IgjkQg+nw9VVSu28c1kMqxatarkePnKmFY0Hjk8yv6BOOF0HlUz6Khz43K4cYpwaizFqmYfTX4ne85EafDJjMZVOhqd9ITStAXc7O2L4XPKBJMK4VSOjrqznOW9vVH29sZY2+anNeBmX28Mtyyyvj0w4fOYaxLLkeEEu3oiYEIkoxIc0dlal0FRdU6OpWn2O4llNVprXGzpqsUpizPu1GlPBj09PQiCUCjmOddkMBm/wPYWyhVgqsa9wFBp1QbLLc/n84yNjZVEwMullnp7e1m3bh2nT5+eYNx2kK6pqWnKa3i+L0Ysp9JV5yab1zgVy1LnlZFEkWa/B1EU0AyT7cvqOR5M4RHdxGKwpKuBcEohkVXprPdYVWiyyMnRFNGMis8p8dsTIUKpPAGPzKEhq1KtzuOgP5pjSYOXYEJBEgU6at0VV9HzQSSd55lTEVpqnIiCyAt9cfKKQb3XiWGaPHZ0lKUNXtpr3bwYzxHLqrxyXXOZQZns641ycCiBKAhcs7KBdW2lPIPiycDlctHW1jbldRV7BsWcgng8jqqqKIpSsZIrm81y7Nix85aDKr/2SwWLyrh1Xefo0aMTVlawVl2751fxbF28csfjcZxOJ16vt+JePBgM4nK5JtQYlyOczhNwyzgkkUhGpTeSZSCaY31bDY0+B3ndpMHnxOuUWNdeQ08whkOCbN5gfXstZ8LpwlhOWWRVk5dsXmcgkkEzTLYuqWUwlsPrlOgNZ+hu9lHjlvnv5wbJaQaYJi0BN6/f1Dbrmy2n6pwaS5NTDbrq3bQG3KQUzQrWSSKGAW6HSFwDwzTJ5HXSik6z34XfJeNzSpwJZ8jkdZyyyMHBBGMphXhG5VQoTSStksnrHBhM8Kc7VtDd7J9wDdPdcxdPBnbxz1SwCUd79uyhubl5WjLS0+EYzDYtOl9YVMatKArRaHTSGyIajbJmzZqSY8VG3Nvby/LlyyccBwpR5+lU/bQG3BwaTtBR62Zdaw2yKNBc40RAwO2QuHFtIzVua5wb1zQTkAxO9Ca5amU9q1r8iAIcHEpgmDCayNHgc7Cs0cPaVj8vDSZoCbhIZDXCmTwC4HZI5PLWjdhRa7nvg7EsJ0dTLK+buUKrourct3+YsXQehyiwu8fktRtbCXgcVjBNt/LPdV4HQ6a1DQmn8ngcEj7XOGEIEMZ/Hjs6xomxNH6XxLOnI4yl8iypd+NxiETSeR56KchHb5q9cc8UgiDgcrmQJInGxsZJn5fXDJzy2VjNuTTlZVnmuuuum/PrnS0WjXHbRfaTIZ1OEwgEKkbANU0jlUphGAaBQKBwvNi4R0ZGaGlpIRwOl7zeFvArxhVL60hkVQZiWTBhx5omti2tq3ijOmWRTZ01eHMO1o3vmbubfTxxfIyhWI6xVJ7uZh/ekRQALlkkllVZ1ujF7RC5truBK5fV8+DBIG7HWY/EIYnWKg4omsmDL41wJpyh1uPgleuaaaudvO64P5plLK3QVWex7dKKxu6eKG+7soutXQG+t6efeFajxu1ge6tEo8/J8gYPK5t99EYyeGSJrKqzuasWzbCChp21lsdT65E5PJxE000kUUDRDfqjGXTDelz+2V6MPXEopfDQwSDxrEqtx8Ftl7XSXHNuTflLySWHRWTcxfXa5YESOzddXNZpQ5IkFEWZkN4qNm7TNBkcHGTr1q2EQqGS109msLduaCGrGkgCuBznzkvbE8TpsTTffKYXSQSvQ6a7yUEmr+OQRLKqwfbOAJphuc071jSyrNFKXa1s8vLokTFkEXQTZFGgvdaNIJg8O6Qg1aZpqXGRUjR+/uIw77p6CX5X5a9fM0zEovclSyKKZmCaJqdCGVY2+6nzONB0g5OnowXSjW6YnBxNEc+qNPqdrGzykVJKCUItATdZVacWA0mQcMkCsaxGJbO4GL28VN3gFwdGMEyT9lo38azKfS8O855rls55DGO+sSiM2161RVEsyBUXG/fIyEhhRS6HKIoFKmdxW6Fi4x4bG6O+vn7SaG8lt1cQBLznIJsUP9c0TY6OJHngpRGGYjlcDoGRuMLyRi8CAqpuncPvkitGxVtqXIRSCsGEgiDA+rYaAm4ZVVUYSelcscRaqQNuB8PxHJF0flLjbq914xBFopk8LlkinM7zsu5GFM1gNKkUXH+QSKkGh4YTrGutIeBxsLYsOOZ3SXQ3+yy33GltH1Y2+fA4JUQB3A6Zjlo3qm7gEq3PK6fqxLMqKUWn4QIbdzKnkVG0gmdT63EwEldIKRoN8tTR/urKPQ/I5XKF/Vm5O12c/iov1wTLiGOxGMuXL6+YF7fz3naBSDmCwSCjo6O43W5GswIjWXA6HAiiTN4UWNro4+ruJlxTsLXsgpS9Z6I0eK399UjCCpgNxTMEXE5ymkat28mShsr00z09UVY0edm2tA6AwWiOYyNJ1re4cUiWwbgdEoZpopsmzgocdhu1Hgdv3NrOnjNRMnmdl69qYnNnAJNxd398rJOjKU7GDB45NMozJyO8YUs7K5stT6I/kuHFwTi94Sweh4jXKdLkd7K6xYd/PNgoCoIVXPQ6CqviUCzH/7wwiKIZRMIJXi34eMXUyYk5hcdhRcjt/baqGyBY26GFhgVv3Paqbe+ly1Nbo6OjNDQ04HK5Cmmy8tcrikJzc3PJcdu44/E4bre7YrWXPXFcfvnlHB3N8MyZIDIGh4JR8qrOhmYnL/QEefFYD9tbSjt/2Gkeu8Y7l8uRVbKYosSqZsuAU7kUKxt9XL60nq56D5s6A5OutopmlBSdyJJ1TBAEtrc56M1omKgYhsmmzgCtgan3j801Ll67aWIK6tb1LTx0aIRMLMcLAwmW10BbrZt0Xufbu3q5Ylk98azKybE0oZTCaDKPSxZZ0+rDKYm8+rJW2ms9PHJkFM0wqfXI3LaxdXw7ZXLfi8M4JJEGnxM9LfDk6TgbV+Rp8E0/R/7SYIIX+uM4JIHrVzWytMKEOJnL73FK3LS2mUePjo4PCDetay7h+i8ULLwrLkPxqg2lxm2vups3byadTles/hobG8Pn8034oouppnY9dzlGR0dpbGzE5XLx/GCIJY0BVMPAHddxuaC+IcC6GhdDCYXLt6/E45QmRF4VRSGbzaKqKu2ONL/tyeAQdFTdZKkTXtmiUS+pOHNOnj8U5EhYQ5YlrlxWx6rWQIGosaG9hl8dGUUUBDTDQDdgZbP1vjprZK5f10U4ncftkOiqc8/ahVzZ7ONdVy3l6EiSrKrTN5jktyfCZFWd0UQOp0Pi9FiKTN5AFKzofSKrIpgCQ/Ec4XSelc0+3tewDEU18DilQiAtrxukFK1A2JEFAVXAcomnadwHhxL84sAIjT4rJvCN3/bw+s3tbOoI4Hefvd0rEViCiRwPHxolmsnTXutm29JaGn2uaZ/7UsOCNu7yVRtK98qhUIja2lpcLhfZbHaCcWuaRiwWqyjWIIpi4TWV/m/Xc69bt86SWjJN5PGb1Cw85+zfti2VC+qBVYEWDoe54aptrF+T4lgwhcchcfnSWgIui3xzKpjgN8eGcYkmmpHn2EiCW1e4aHQaBRGINtXgTD+4HDLbu/ykxgbJjHsFQj5Nh8+Jy3X+udg6r4ONnQHuPzDEcNqku1ZmLGmRZ5I5lYDbQSKXQzPOxiJMTKzQhPVBOCRxQnmrSxap9zqIZVTqvA4UzUB0CdR6pn/NLw7EafA68DolXhpIcyqUIZ7tY0WTn3df3VXg5Jcbdyqn8f09AwgC+JwyJ8fSyJLA713eOdmpLnksaOOuxEazV27TNOnt7WXjxo0lx4sxNDRES0sLmUxmwtiiKBKNRiddtWOxGF6vt2CkVy2v51dHxgi4JByiQCpn7e8HYjm2L6vDPUXEvFgEYlWLn1UtpTlfj8fDqViM+lo/jeOrSDiVJ+/3sX1ze+F515VVd9lega7rDA8PF45VImdUKugo3jaUw++S2bqknhd7giSyKqIArQEXyZxGd5OP3kgWv0tiMJ7DIQnoJqxssii3lRBM5BhN5rl8SS17e6MMx3Mk8zpvubyJWo+DvGYwGMtiAp217kkzEC5ZQtXzhFI6w4kcPqdIs9+FJJg8dDDIH11nZUzKjTuYVMhpOh211varo9bNsZEUmm4gTxGfKEY1oDaHePWrX839999fcsyWQrI54raOdKVA2/DwMJs2beLEiRMTxtZ1HUVRaGhomPA/291fumx54fG2pXW4HBLHgimWNXrxOCTy45zyTZ2TF5mkFA1V08/ZVFCWrD2pDUXTGU0qHAumWFrvweOUKlZ3pbM5Tg2Osqx7zYR9Y/kWYTSeZiCUxiUk8Ip6YTIobulbzNduwKDVY6KZOqJocjqUQRIFDGBjR4B1rX6Sikatx8HKZh9bu2oLLng0k+fpkxGSOQ2nJHBgMI4oWK+9cmkdr1jTxMmjGVY3+8jmdb73bL/FGwCa/S7+8NqlJW62jeu6G/jBngFGEjnSik5TjVUjLwKxzNkqtXLjdo5/vvYWL69bAbXy3PtCwoI27kqKpvYKPTg4yLp16wrHK5FSmpubcTgcFffikUiEmpqaCeMLgsDRwTDfejGF4+QAq5o8vHV7Jy1uNxs7AmzsqJxyK4dhmDx8KMiunogVhU6rbLtSn3SF376snkPDSUbiOVTd4NBwkq60hzPhLI0+B++9bhmBMvc1lFL4j2d6OT2g8FT0BLdd1so1K89OVhnV4NEjYQaiOcDkWDDFaErBNOAtV3Twliu6SsYrVoNRFIXVbgXDgJF4FrcEbR6dRCJBLpzh2laZRiGJMzDuAegKweGU1b3TlPju86MourXSPn0qzIb2Gla31GCYJvv6YmxfXo8sWp/3njNRBmJZOsdJNcPxHL89EeI1m9qIpPP88mCQoXgOpySwoSPAjWubGIkrqLpJd7MXlyQwGFfY0nX2uyk37s46D+vbazg8nEQSBEzgDVvaL7nVeCZY0MZd6YOXJIlkMonL5SpRLSkPtA0MDLB169aKHHJN00gmkxMi6AAZDe556DgZXcKdz9ETzqDoJp981boJz50KB4cSPH0yTFe9B0GA54MGjx4Z5bruRrxOaYKRtwas1erQUIL9/XGW1nvoHk87DSdy/PZkiHqvk+PBFPUeBzvWNvPjvQOMJnMIGDhlgQcOjrCs0Srs0A2T7z3bz2Ash88p8evDo2RUnY46N5Ig8P+e6WN5o48rl1u5/zPhDKFUnlqPzKrmQOGz97pOctvaJYjj6aLhhMLtW9sRBTgeTOKXYFOjB8FQC5Vdh0dS9AeTNLhMcrqBltM42pfDq8aRJIm4Aid6enFkM0SjUQbDeRzC2VXV65SIZFQUVec/d/YSz2n0RTIMxXI8cyrCymYfN61p4hWrG3nowDCaKXBZRw03rzv7fZYbtygKvHFLB5s60mRVnZYaF+1TsPgWAha0cdsueHlALRQKFfbaxceLSSl1dXU4nc6KuuNDQ0M0NTVVJKccCRuMpTWWN3sRBNGiZvbGUFT9nEy0YgzGc7idUqEGWxLg+3sG2Hk6giSKvPWKTjZ2lnoBLTUuWtY2E0rlyaln3Xi3LLHrVBTVMKj1ODg1lubFwTi7TkeIZlRUVaMhMUZ7nYdIWqG91k0knWcwlqOj1s2ZcJpIOo9qGPRHDNoCbhySyO6eCFuX1PKT5wb59ZFRvC4Zj0PkhtVNvG58r1/rElA03aoMM0x0w+BYMMne3lhha3I8nOeD1y8v5LJz3gSNkQGW1FuTb9AIE0nnaWlpIpbJE5A12uu8BFNjJBIJXHmFgWCKdHQ8UJo1aWh38PizQU4PKnicMmMxhQaPg4yqksvn+cqjJ/A6ZdJ5naX1biJplceOjhWuu1K0PKfqZPI6umnimcF3aeNSW+UXtHH7fL4CZ9yGrRdWXh1UHGjr7+/nsssuAyZ+IYZhMDIywpo1axgZGZlwzlw+jyxJ2FFfUbS425WEDadCi99JTtULE8iJqMGyFomOWg85VedH+wb4RP0q6r1nA1CZvM6u0xEGolnORDL4XRKiIBDP5olmNNa31yCJVnT5iaNjRDMqsiggy5YLPhDNEs9agT5JFDAxyak6x4IpDEx0E/KayZlwhuYaJ5IAn/75YR49OoooCtQ4Zda0+njqZJirVzTQXOPiZR0yhzXLezAMk2tX1LOrJ2qx3MY/k8FoljPhDGtare9kRaOXRp+TwVgWt0OipcbFqmY/4axOg9/Dm7a201nnIREepbu7mw0bXNS3hnjqZBjTNHnT5fW8cm0Tg5EUjw2fQcJAEPNouo6qahwdjJHXDIy8gleG3tEcPkPm/r0RlopRfB4XqqqSy+WIRqMWB8IQ+b/P9BFOW/UJPqfMh29YQUvN1HyASxkL2ri9Xi+ZTKbEuO30VzlsI7Z7cE/WsM3OXVfaixuGQZtbpyVQQzynIYkCaUXnlnWNE1RQTo2leeClETJ5ne3L6rhpbXNJcGZLVy3HgileHIxjmiAKFFZqt0PCzOSJZtSCcSuqzjd+28NgLIdbFkgrGi8NJemsc3PzumaePBHGME0kBFTdookC6IaBYYCASWOtE6/T+sobfE6uWFrHE8dDpHMakigi6jq6aT0/r5tEMyovDSZwyiJu2SpEORPOsdYhF4pS6t0if7q9m1BKwSVLNPud7DwdLeGmC1hloTZ8Lpn3XreM3T1RUorG2lY/l5XFKuJZlaGkRmdWo83t5qZ1zbxitVXBZUevl7fUsn1FM3vORDBFmZRm0N1Sx/GxNEvr3SRyGjVuGTGn0tBQQ1rRaG1twdQ1IpEIqqoWsgg7e1McG1Fp9AgICAyrAt95NM7rN9TNKItwKWFBG7fP5ytJY6VSVuXUVHW1vb29E8o+bdh78U2bNqHresV67uUNbt61pJVfH4+j6ibLl7v5g6tLc6HD8RzfeKoHr0PCKYk88NIIpmly64bWwnNyqkE4nSeZ1QCBOhfkVQOnJJLXDEygrihA1hO29pRd9eOcZ6+DSDrPXa+x+onLksQvDwZxySL7+2No48akGeCRoMbnpCXgKmGmvWFzO121bv45eQrdNJF8DsbSeSTR0mo7E84gipbbr+rWZ5HTNJySSEtRSsvjEOmLZPjloVF0w8TnlBiIZmjwucgoGrVe5wSWWMDj4NZyEUhF47GjY7w0GOd4MIWgZHh89DRvv2oJVy6vn5CSEgSB39vWwfr2Gs6E0hwNppAEQBSocckYsSyRtIIgCCQUnR1rWmhttrisoijicDgK3WbOMEQnMZprXJimiS+Tx+kWaWxsnNDG1xZ/KM8irFmzpmJ25WJhURn3mTNnaG9vr5i3Biva63K5JhUBjEaj+Hy+AlW1XFttYGAAn8/HhmUBXr62jbxm4HNM3GedHE1h6Ca1Acs4W2pc7O2NlRj3/7wwRE8ow4omL5phMhoSCKZyJBUJE4E3bu0oYUbphkmxcyAKQgkp5IbVjdR7HDx9KkSNx8G2pXW8NJRgKJYlkYOVbU4+cP3ykiCRKApcuaKBu17r4M7/OsBoMo+MgCBZq/+ZcIYal4TglkkrGklFo8Hl4gPXLyuJLxwaSvBfzw3RGnAiCgJDsRxrW/2W0ESzj5vXNZ+ziCavGfzrkz30R7IcHUlak5sE3T4H//XcIGtb/ROyAWBtLzZ1BtjUGeD148ci6Tw/2juAqpv4nTIb2mvYvqyOq1ecNTx7zz0Yy/LDvQOcGE0RTChsW1KHxymRVAxeuaGVpqbJ671t2NyC6YhLXkgseONOpy3VkuI2u8lksuLz8/k869evn3S8vr6+wkxe3jooGo3i9/sLgTmPQ8LjOLuPL4ZTFtGLjqmaQU3ZjXlqLE2T30kyp5FVDQTB5PWb2ljbVoPfJU9gZS1v9FLrcRBMKHgcIvGsxo41TYXtgCAIbFlSi8sh0hPKEPA4uGZFA6mcyvG+Ef7vOy+fNOC3rq2GT9+2lr+7/wjxrIZLFnDLEomsxrJGL+F0HkkU2NpZyyduWTWh8utoMIXHIeKSrfHrfQ5A4IMvX8HBwTi/PjJKwC1z/aqmgkhFOX57IsQLfVHqfS4kCfxOmbF4DocoYpo6iZxW0bgrocHn5E92rKxYI27DMAxyOnzryR403WRpvZesqnNgMM6mzgCv2djCtSumtwrbMtKXUvteWATGba/Sdhteu+SzHHZfsMlUSxOJBKIoFmbf8hRZT28f3Su7GRsdqdjpsxibOmt58kSI/kgWaTxX+/YrS3PGLTUunj0TIZhUEEyIpU2G4jluWlfqqhbeq8sK8Pz6yCjRjMoNa2p4+aqJq8rSBi8NPicjcauqLJbV2NYmnzOSv7mrlqYaF6IgkFI0onmL8BFK5fnCGzbQGnDR6KvcrqjW7SCvnf0McnmDOo+DnafCfG/PAG5ZJK8b7DkT45O3rJpApnnyeIjvPtvPQCzHaEolm9cKVN50XschC9R7Z06bnYqAYhgG4YxORtEL5Z0b2gIMJ3J84pWrKxJkFhoW9DuwA2rZbJZMJkNDQwO5XK4i26u3t7eQ+qpUJGJrmduwa6wN0+THe/p4+ECawIle1tfq3FF3dvxsNsuhQ4cmaHLfvtLB6ZiILkisbathRaO7cG7TNHlZdwM/fWHQ2kcKAs0egT09Md60tWPSCqQGn5O3bu+q+L/CZ+KU+JMbVvLIkVHCKYUbVjfhCKfO+VnWehxs7arlh3sH0A2rJLTBb0lD7euN8QfXTq7Tfm13A8/1xRiMWWSYgMvBrZe1cO9jp2jyOwtppcFoliMjKbYvqyu8VjdMfrp/iKUNXlKKRjKrIYoC8ayGTwYDeN91y86rKkvTDYYTVoCxfVwi2jAMPE4ZgxyGaYlTqLqJJAgLTpRhMixo47ZXbltFRRCEiiu3oiik02mcTie6rld0n3K5HHV1dYXHNt/7mVMRfvnSEEuaArjdLvYORelsSPCG8cDM0NAQS5cupaurqxBosYMua+sN8vkcmbE4LwyeRtM0EnmTX5xSGU6bZBSDZXUOWvwutBwoeYVgJEZHvf+8orF1Xge/f4UV5DNNk127JtJryxHLqPRHs/iclkQS49VYG9triOcqt0C2PRa/S+ZjN3VzLGjtlbubfAQ8DnRjYorQKPNydMNEN0zcssDmzloGolmCCYW3XNFOc7afm1+xbsZpxuLre74vznee7SOaUfE6JFa3+PnTHSvI5TUafTLXrmjgmVPhQnT/96/onLVxV/Pccwifz0culyORSBQi4JUKRPr7+1myZAnDw8MVXXZFUVi2bFnFL+fIcBIHOj6PGwQBn0PgVNiSdNI0jWg0yvLly5EkCa/Xe85eXl/+1XEET4b1DTKJniiDSZ32gEg0b9Lg1oiPDhEdmtjut9grqPT3bGR4izEYyyIKAtuW1vHiQByHJGICOc1gyxTceLAEFv7vUz0MjJNiPvjy5QQ8Dm5Y3cgvDoxYFV6qgc8lsbrF2vYcD6Y4OpLE55JZ2+rnyHASTLNwHcsavEhjwnkZ9nd39/Pfzw8SSo3XlLf4OTqS4G9/cYShcBxRknj1pk4+9IoVJBWNtoCb5Y3n7sW2ULCgjdvv96PreqE1EEzcKxd3GAkGgxOMW1VVNE0rWbWLIeWTCE7LsHXDJKWa2Nmk4eFhWltbK76uEgzD0iBrD1higduW1fNcb5TRHDS6Zf7X7VtxO2R++sIQe3qjNHid3L6plU2dfnpDSUxdw++iRKC/XJPblvktngDsktKpWv36XDKGadIacLG5q5bTYxnyusEbt7RX3NsXPj/D5J8fO0k6r9Ne6yKazfPPvznJR2+0OrqsafGRU01aml28dmMrw/Ecd//yOM/3x2jyOfG65HHCi8CTJyIYpiWZ/A+/OsktnTovm8bnqukGiZyG3yUXVt2+SJanToVxSAJ+l4wkCpwMpWn0OTgdyuBAI6drfGtnLx+/qZvXFlXXLRYsaOM2DINvf/vb3HHHHYVj5TdtcYeRSqv64OAgXq+3ItXUNE263WmCLY0cHEpaqwomjaMKoZTC8PAwW7Zsmfb1iqJAg9dBUtEIuB0FN/HjN3cTPXMIlyzyv+47zPN9MUsWeFziuHU892qYcMWyOv745csnLUO0a9yLtwiGYTA2NlYi2m/DVoVxOBysqzV4fiSGLIosrXfyR9d0cXV386RtikzTJJmHeFYr5M/rvU56Qxn+7oGjCFj17LUeB++/fhnhdJ57Hj3JydE0mDAUV9jS5aI/miGcUgm45XGhRYNYNs9jfSof1Q2kKVbvU2NpvvrYKVJ5Dbcs8ZEdK1jfHiCr6siCQK3HSSSdxiFJGIZJOKWQVU1EDNyyTCav8+1n+3n1xrYFXQFWCQvauB955JGKlVs2dF1ndHS00GGkUtlnMBikpqamoruuqirLOjpYWtPK3z5wjPXtNXjQiGQ1vvabE7x9XS0Oh6OiNttkeP/1y/nq46cIJnLopslN65pZ21bDnj6R5/ti9IUzOCURr9MijgzHc8QzeV62yuK67zkTZVNHgFesqSwsJooibre7hIFnd1EpR3kPr7fU5dgSTBHNKNTKBu7UEHv3nil8NjZZo1iEXzI1EuksOUXB53YScMkMxrN01nrobLCquEbiOR47NkY8q+EUrTJKh2iVVQ7FcnickqVzLlidWCJplbxmkFHgh/sGefPWdn783CAvDSZo8jt59zVLWVLvQVF17n3slOVx1FhNE776+Gn+8c0b6azz4HSIyJJIo9/J8Ph5ljZ4OTKcwuUQkSQB2bQ45ZF0nubzpJpW99xziEwmU7E1rb0KDw8P09bWVqKvVkmLvFJfsLymM5pSWdfYysmIgs8l0+J3ks3q1LlEjg3H6bx5+qu2je5mH597/XqG41Y1Vue45JElyqcjCMXqLQKabuD0yIXHDklkKJ4753kUVSeYVKYkj1Tq4VXWtRhVN8jmdWrcckFvzp4Mstksj/SqHB5RUQ0QAVm0qLTRVI5QPMGSgExOhYGRMQRRIqcoNPtkhuJ5ECCn6bQGXNR7HVZvtZRCXjMRRYFmj8kjh0c5NJxgIJqjwWu51Hf/8jh3v2kD2bxV6GHzv/0uSxFmLKWwosnHn9+8iv/c1YduGly1vI63bu8ir+p84PsvksvnkWQBn9tBg8+5IAUQz4UFbdx33XUX//Iv/1Lxf4ZhMDQ0xLZt2wrHiokpthb5li1b6O/vL3HXRxIKX3zoCIMhkftHT/Cy7npU3SCSzqOpBmpepc4j4vf7S7TNpzNz64ZJXjOo88j8aN8Q+/qi1LhkrmvQuGF7DU1+F9GMSkLRLCqnSy50+jBNS2dsWcNEscZiDMVyfOlXx4lnLUHEDT6Va6d5fWNJhVAqT3ONk55Qhn/9bQ85VcfrlPjjl69g+7K6QtDw8aNBnhqCgNeJgOWe66bBymY/I3GFUM7E53HgkGBbVw1OweD5/gToOi5RJ60YtNfovLLZwOeUMHICT/cbuCToqnVSJ+VRVJUX+3NsaK+xvBKHxGhS4XQozdrWGkThrLJrgbY7nhNf1ujl715X6rGYpsm7r17Cz587g8vlpMbt5PWb2qZNkJkMl9qqDQvcuIsZasUQBIFgMEhjY2NJ2qvYLQ+HwwQCgULKqXjl/sZTvYzG0tR7RGo8Eo8dD5PMaoTTeQzTxC0afOl13YUx7a4j5/qCYxmVLz9ygr5IhsFYFkkUuazdT143+Z/jea7ZonPXa9fy/Wf7OR5MsaTewxu3tvObYyFOjFq56pvXNpfQKCvhG7/tIZnTaPK70A2TnUMJjowk2VBB77wYTx4P8c1nzsB48Uk2r1Hvc9EfzZJTDf7sxwd473XLeP/1llTRfS+OkNUA1cDvkuw6OWrcDnwuB2fCaQwEPnbzaq4av+auri5+eyKMicnLVzWyoslX6Ped8w9xJNJLKqcjiVYAM59XEHSD0VAYSbCMM6bAqePHkGNeXr1M4qdHkgiigCCIvHN7O16p8veR1wyiGZW3b+8kODLM8aREc42LTZ1Tfy4LFQveuCvxyAVBYGBggM2bN5ccLw6o9fX1Ffah5d1FTo+lqHFarrJDFBlNKgRcMpcvqSWVyRJOZkkY01fENE2TnacifOXXJxlL5VjV4kfRDHTDolU2+Jzj3TzSvHpTJ3e91rqubF7nP3f10RNKU+uReffVS7l8Se05J5HeSKZQTWYFiUz2nonx0xeGUXWDW9e3cF13Q8k4sYzK/3uml4DbgUsWGUkoDMYVEjkNw7Bc3mxe49GjY1y1op6ToyleGkqOX6eGOt6AUBCs53oc1qT3+1d0FgwbrNX03WXpJkEQ2NeX4IcvjLKi2c/J0TR9cZVaB7zvhpU0+Z1879kBDMHyfK5eVsOrr12KruZpa8sjOSMcGk7R6IZmM8pLL42WtJZyOByMZEW+fyiDYkBONVHyeTrqfQzHMnz+oWP8/e0bWLaI0mCwwI3b6/WSzWYnHNd1nZqamgm9nYq1yB0OR8G9LDZuQRAISCoZ0YVDz6MZBnnNpKZWtoJcOQO3Q2QsdfbmOZex7Tod4d7HTzGcsAT+jgynkCUwTEgrOvVeExMBr6N03/eN3/awqyeC3ykzFMvxT785yT+9ZRNN/qkDP8sbvfRGMjT6rJU7r8PP9g9R45KRJIF7Hz8FwMuKUlyxrBVBt/eefpeEOd690+OQ0AxLKFAUrC6m9780wsomD5mcQka3RPxrXDLr2vykFI1EzqS72Uc6r/NXPztEndfBO67sqqghDrCvL4ZLFgm4HWxdUksomcdnJHnHVVZMpaPOw6nRNA1+J1cvrx9PeXn41eEg3z8QByy12aDu43+9elMhm2CaJumswtd//BIOh5OAQ+DgcJqcCu26imyohDIaP3h0LzcscSCK4qRcAvtvWZYvSTe8HAvauCdzyxVFYe3atROO2yt3X19fSd+wYuNWFIXXLBN4OOhmNKKQS+e5clktwaSVUsopCgYy3U1nb9JzddH81eFRvA5pXPJXAwF8TomcqpJTdYKJPN31Mps7zgpMGIbJ7p4IOdXgTCgB4y7po0dG2bGmmZYa16Qpqg+/YgVf+tVxQikFwzQJOKAvnmPQtET3O2pdPHJktMS4m/1OHJLFK7cbH7QF3CSyeVKKjksW6W72ohnQVedBQEAWBVbWSsjeGiLpPH92UzcvX9VITyiDKArsPBXmJ88PEnDL9EUyHB1J8pXf21hxcqr1WK2Nwap4EwSod52d7Crp0xmGyXd299PgdeKULU/h0HCSwyNJNo8TbwRBIK1B3hBoqrFiFW5Xnqyq43R7qfW6UKQca1Z3ct22joJOXHHgMJ1OE41GC8eLsyO20dfX11dsHX0xccGN+5577uGTn/wkY2NjFZvY/+Vf/iUPPvgghmFwyy23cO+99046S7rd7gldRGKxGLIsV6zpFkWRTCaDqqolAg+SJBXcuMHBQS5fvYQbr23h6ecOsXrFElobAnzjt73s7QmjGTI3LHVz1fK6wuttvng8k+f5/hgmAlu7agslm05ZxDCtFfXoSIqUoqEbEnds6+RlKxvwuWUInykUS1hjWg35+iMZZElAGF/lv/Lrk/zkhWFWt/j49G1rK3Ygaat18+U3b2Q0qSCJ8PZv7CSvm/icIoqqczqUYV1raWWXzyXzyVtW879/c5LR8Sj7PXdsJK/p/MuTZ4hmVEzgPdcsYU2rn9s3t/HDvf1omolbN1jS4OXq5fW4HRLr2vzEsxqPHB6l0efAKUv4XDCaUDg4lGTHmonG/dqNbezuiTISz4EANS6Z69unLnbRDKudsEM6WxknCQKKWpr5qPU4kEWBrGp5IS01TsLJHOm8Tk7L4XfJXD8+0UmShMfjqdhhphx2n29b/edSwwU17v7+fh555JGSbprF2LlzJ8888wwHDhwA4Prrr+fJJ59kx44dFZ9f6QPt7e0tiWIXQ5Kkilrk9sqt6zqhUIjt27cjiiJdtQ4avTIeh8SdN63gmT0RulesITIWLJzbPs9oPM3f3H+ccNpyb/0umc+/fg2ddR5ed1kzLw3GUTSd1oCTVpz8xS2ruGJpXSFNty8sMhzPsdTlwTXer6rJ7+TQUBJBg4JzYJo0eh0cG0nx3d19fPiGlRU/G6cs0lXvoSeUximBCxFFs/bEmm5y/eqJrLP17TX8y9u3kMhqBDxygfr5L2/fQjyn4nGcFW5849Z2/C6Rh/ceZ8OqFt64pZ2Ax4GqG9z72Cl2nopwJpyhzutgXZvfqj9n8kqtRr+Tu9+4gf39cUYSOZ48HuJfXlTYmTjEx1+5qqLckVMW2ba0juf6YtR7nWTy2riHUVpX7XZI/NmNK7n38VNk8jqiIPKmVQ7aOpvxumRuXd9yzvZKlWD3+Xa5XJekKssFNe6Pf/zjfPnLX+YNb3hDxf8LgkAulyvwqlVVPSe9s9gltpVY3G53xcowO09b3nDdNm47721/UfZxwzSJRGPU+dzU1fgIBc9OHLZA48NHQ4QzGk3jN2EknedHzw3z5zetYF2rj7tevYpnTkWRRdixppH2gKvgLezri/OlJyPIchKP28Ff37qKFU0++iJZ3A6L9JHXdFTdulEFQcDvkjgxOnFLUo4at4wkwppGP9FMHk03kSWRK8YbBpbDMU76KP18hBItN7C+qx2rG6lNubnqqrNbnPtfHObpk2Ga/U4M00NPKMPxkRT1PidtAReXL5mcp17rcXDFsjr+5AcvklF1vLLA8WCKzz5wlK++dXPFieEjO1byn7v6ODCYYFmDl/dfv/xsgHIsTSavs6LJx/bl9Xz1rZsZTeZp9Dk4fuA51m7u5KcvDPPt3X1cuayeG9c2XZIr8GxxwYz7vvvuo7Ozc0q65rXXXsuNN95Ie3s7pmnykY98ZEpxhXL09vaydOlSIpFIReMOh8OT9gWztc4vv/zykuMPHQnz04MnSaWzbF1ax4dazhJe7N+SJBEbFyO0RzZNk18dHuPZMzG6m7z8+Su7ed/1y0vOaxhWauafHz+DaOo0+P2kVYO7f3WSL71hLR5ZoK3GSSitWhOObtBc40TTNZI5jcu7AoXWxfZ7KubYAzT5XdzQJfNczHJJTQe846quCcY6HQQTCv/vmTMMxXNs6gjwtivaJnyWR4MpXLJ1PS01VkDP45R4y7ZOXrWhZdJGhjb6I1kyqk6dRyaeF6jzOxlJWD3GKq3ePpfMn+4o9V4Mw+SeR0/y9KkwkiDgcUr8/e3rWdHkK7zv/arJX/z0EKFUHock8PTJCOF0nrdcMbv2QZfipDCnxi0IwqNAG1BQFwX4whe+wBe/+EUeeeSRKV9/8uRJjhw5wsDAAAC33HILTz31FC9/+cunOidg1VXbZZuxWGyCW67rOvF4vGKBiCRJZDIZamtrESSZ/9k/zP7+BPFEglMxnXqvg5G8wSPHojxzJsG1rQKXbTIRxr0GQRDYtrSWJ46HLdVN06QnnKXB66DGZfWd+swDx/j729exrzfGc31xjo+mcMsS166sR9U0fG4r317jEolk8oiSRZXsj+VoqrGa6UWzKqZpNatfUu/mnVd2FHLENoo9GUEQyKk6y2sELt+wBEm0xPfXtNag6/qElsVTIaVofOpnh4ikFTwOmfsPjDAUy/C6snqLrnoPe85EC9chSyKv2tA6baPxuSwOuFUaajH0TBO805AaVlSdb+/u47FjIU6H0nQ3efE4ZWJZlXsfO8U//76VGg2n8nzrYJ5j8TyNXgcNdR4Mp8l/Pz/IHds6LklDnQ3m1LhN03xl8UP7j5deeomenp7Cqj0wMMC2bdvYs2cPbW1n28T+7Gc/45prrinIEt92223s2rVrSuN2OBzk8/kJNd3lK/fw8DCNjY2T9uhOJpOsXr2abz7Txy8PjeJyiAzHFHKaiaJq5AwBh2TdbC+OWn2nXr2uAVmWEUWRl61sIHKtyn8/P0RK0Qm4HSxp8CJgFVMMxXJ85McHGYlniWRUHJLI0noP//X8EJmsgr/Res85VUcWrRa2/+u2Nfyfx3s4PppiZZOPj+xYjiSK6IZJZ7170h7bBaJOOs9f/fQQg1EN58keti4J8Fe3rCwUjpRPBPbv8r9fGkry9788zonRNHUeB4FGJ40OJ8/1xbm5ufQW+r3LO3hpMMHpUBoQWNHo5a0zWA2X1Hu4ZX0LvzocJKMYaJLGu67uKiijHAum+M7uPtKKxo1rmnn95rZC1uCffnOKp06GUTSLMnt4JIVTFBBFgVzeKHy+n/rZIXoSOpouMprKk9MMljd4MKZOeiw4XBC3fNOmTYyOjhYeL1++nH379k2Ili9dupR///d/56//+q8xTZMnn3ySO++8c8qxfT4fsVispKa7XP/MNE2GhoZYt24dfX19E8bIZrMWz9rt4eHDY9R5HUiiQMAlkc6rJHMmkiRhYuKSJSRR48hIitvWNxYCYoIgcPvmNm7f3EZ/NMuf/ddBTMNEEK0JIZpRGUkqZPM6hgkCBrGsSq1Hps4nktVA0VQEAT7xyu6CRttnXreWnKrzb0/38ulfHKXW4+AjN6yY1LDt9w/wzZ39DETTNPrdyLKD5/oSPH4ixms3lcYxyoUgbaM3DKtw5W/vP0JeMxAwiWfznAlZFFjTNBExC9FiQRBwywKff/1azoSzGKbJymb/lE0QyyEIAh96xXIu7/Tx3OGT3LB9fSEF1hfJ8KmfHkQ3TGRJ4BtP9aBoOr+/vYu8ZvDUyTD1PgeZvE4wYSnM2iz8pKLzXG8U1zh9tdEtouZENN0gntUIpVXeur1z0azaYHH9Lyr27dvH+9//fgDuuOMOuru72bRpE1u2bGHLli28/vWvn/L1Xq+XoaEhurq6Snp0F9+wY2Nj1NfX43K5Ku7FR0ZGClVUxV9twC3iEEEQLTqmALTXutAM6Ky13OihuMLBoQSJIrWSrjo3r1rfTDSrMppUGEvlccoCimYUWvlqBmRVnZySZ/OSOv717Zv47OvX8m/v2MJV4y18bPyfJ3r41SGrWf1wPMenf3GEwdhE8k45esMZZHRk2brhR5MK/+eJ03z32X60os9HFMXCjyRJBbE/h8PBybCCYQo0+l14XTImFoc8mlG5aaWfhtqaQtcWTdMsr8DQ2d8X4ZP/c4jXf30Xn3/gMPFUppA2smvodV0vSEgXf1+CILC1K8A1na6S3Pbu01GyqtVVxeeU8TklHjwYtN6DYOXHDcPE75LRx5dhAQqxkH97yko3miZkVQOH3e1FFHj3NUt499WTS0mdC5fipHBRSCxnzpwp/L19+3a++c1vApZR/tu//duMxvL5fIyNjZVQTSVJKuS/izuMVOoLpigKiqLgcFi50NduauH+A0Ecskg2Z7DUD++7YTXff26YlKKjaCZLawRu39TC9/YO85MXhpFEAVkS+cLt69jQbpWg/vHLl5FTdX7+4ghOWbRSZKYlO2SYBoZp0UvzKozmRFTdZH2ZqqiNp09GqPVY3oRTEolm8uMNCabOxS6pETkdlMmpOqfDGXTdRDNNvr93EFU3eO91y6Z8/XA8x8mxFBlVI+ASWd7gJZjIoRomH79pJY3KMO3tSyfIVj3bE+VbuwfxuSS8LonfnooQ8Dj40PVLC99J8Zag0vbA7i6aziq8MJBA1U2yeRWrT4pltKZJIcctSyJv297JD/YOWI0Yxod0SgKyJJDXTXKqwapmH3VuiZOjIEkamOB3S2zpqp2UFLRQsaAZamBFwB9//HFuueWWwrFiI47FYoX6ZjuXXQxbzMFuHfTea5fQFnCxfyCBnE9xTZPMjo1t3LSuhZ5wBlEQCJ0+SH9U4ScvDOMdb52bU3U+/9BxfvDebQiCwJlwlkeOjNHkdyJLItGMOu7aWjecOq4vVu8WOTKS4s9/cohvvmtLxWiy2ymiGQaSKI0bgoDnHCWKwYSCS89Q63MyElfQdJNGn4NmvwtVN/j1kdCUxr2/P85d9x9FM0ziGUu4sMnvxOOU+JtXdnP9ynr27DlFTc3ECenFAYsOam8dfE6Z5/viU0r/lm8NkskkksvDnT85RG/Eqh9wSCIuWSScUhAFy7g/+DJLu04QBO7Y2kLAJfDlR0/jGDfovG6iGVYJ6c3rmnn/917gpeEkCJZ8cmC8nPahg8FzFtYsNCxo487lcuzfv5+PfvSjJcfLC0RWrrRSJTaTzIamaYTDYbZt28bQ0BBguXav29jK6za2smfPnkJ03SmLrG21yDGhUwbH+kfJ5lWrR5ZpuX4Bj4yiGzx5PMyvj4xaVM7xQFBnnZsz4QxtATeGaTKaUmh1m3i9FgEipWgcLVMGtfGq9c18e/cAApYEUXezj2tW1k94no0z4Qx/9l8vEU1mcbmciCJ4nJYmWixj6Yn5nFN/9V/+9UkASx3FKTGWynPT2iZet6kV3YDHX+qjKdBQ0R1t9DsxzbNlsIqq09g0dVFGebQ+EomwP+bmdChKncficidyGisavWzsqCGt6Lysu54rltZhGEbhe1V1A6cksLrFx1A8RzyrWXGMm5bzq0MjBJMKpmGVz8ZzKo0+i/YqcHaCuRQJKbPBgjbuVCrFjh07JrjatnGn02lM0yysLuU34sjICK2trVawrIwfbuucl9NYTdOku7ubxECccMaKvIsCKKpJzMjzv37wDPuCBroBibxJTtXoDDjJ67Ciwc2f7ViKy+nkMw8ewzTzhZJRwzRL6Kc2fvzcID/aZ008ed1gfbuff3zzhkIDgEr49u5+Urk8dV4HTqdMTzg7rmyigyDgd0rceVP3lJ9tNKPiHxd6kEQBj0NkVbOfb+8eYF9vDE3N4/e4+GpbhpGEwvf2DGAYJm++vJ1XX9bCo0dDnAml0cc10T708qm3AOWfcSKRIKla7Y3t780liyRyGh8o4wsUG6MgSggIiIJAV52H1hoDQRB43aZ2frBvGFU3UQ3LtTdN6Ilk6Krz8Kp1DYWt3FSZg+Jjxeeu7rnnGE1NTWzevHlC2aftltvpsUqwI+iXX355xS9mYGCA5ubmis0Am5qaWGL4qPOEC4E0l8PqrvlCBOprJAQT5EyeSEYjntPxOgTet9lHXW4ENalyRZ3CziBk1BQgsKLeiVcJMziY4lRM49vPhUgqBn3RLC01LvxuS8Dw1FiG4bhCd/PkX108q4Ku4/C6UDQDTTfwOyU8TkufzApYTa1ourkzwP7+OLUeGVW3dL1j2Tx7zsTwO0WyuklWNfn0L44wmswjCtY++Eu/OsFf3NJNk9/JrtMRVN3E6xD519+e4QtvWE9ONRiK52j2u2jyTyTSnBxL87kHjjAYVemoj6EbllstCVaX05vWVZaXsnH18nr+09VPPKfhEK32wm/f3onf40ASRaIZBUmwJmTdBJckcsfl7azvqCt8vzaKYwOT/QZrkXjwwQf5xCc+MeW1XWgsaOOGyjXddiGIpmnU11d2X0OhEHV1dRULTFRVJRaLsWrVKsLhcOF4MSOtwefE4xSp83oAy93PqQZgGYIgCjTWuHE5NO68aSU3rG4sCOsbhkEqt4sxwcuRkRQBt8wfXdtFbY2T02NJPvPIELph3VipnAlGhjqXAAhoBrx07BRC0l+xHFEURa5dVsNzPSF001J9AYGAxzHegUQlm9d59kyUV22o3N0E4K9etYrPPXScQ8NJXJLIJ17ZzWA8N64zriNLMqJstS7yOiW84+8tk9f52hNnGE1a+3wTSKsGvzw8RiKr0he1KtUM0+SjN67kDZvP8hziWZWP/+QgiXQOt0NmIJ7DLVs90A3gZd0NfOBlU3sArQEX//SWy/jPnX28OJgklMrz7d0DHAmm+dNXLOOvf3EUwxwXq/Q4cMpCWf+06bvk9v2wc+fOSVtYXUwsSuO2q79Wrlw5qbvU398/KbV1eHiY9vb2CSk1XdcLKaPOOjfvvnoJ3322v9CU786bV/DwoTGOjCRxjcv+NPmc7BgXM7R7V42NjfHj0xInIxlq3DKKbvLF3wxy71s28vRwkrwhjleUmSTVLBnNpK3OSzav43MJXN7djlu0VE7j8XghxWQrnTblctzcJbB7VMEhQJNXJK+qjCUVq6uGJPClX50gqWjccXlHxc+g3uvkn+7YSF63UkaCILDzdARZFEhnFTQk8jmLp50tqsIyTJN4TkPTDYp9HtOEZ07HaKt1IQhWm6K/ue8ovz0R5nOvW4vPJXNiNE1eM3CKJk6HjBMrXfj9P7qCep9jytx+MZY1eLlpXTNPnIxQ53UgCrD3TJR6r4M/unYJP3y2D6/bgSgKBNwOrlkxefxiKtgTwbPPPstb3/rWWY0xn1jwxu33+4lGoyXH7FK8lpbKK5Mt1lCprM80TUZGRti2bRvZbHYCj7w44vuuq7q4dkU9wYRCwC3zwMEgOc2gucaFKFglnm/f3smHfniAnlAahyTyV7euoi4zwJGw1TtaEARkCRJZlfd9bz+GaVrqJyY0+hw0+pwkchqZvE5bwMXf3LaGZa3+CdddfP27d+/mL990eaE2eSia5ou/GSCSzeKSIOACU8vzfx49TmeuF1mWJ3gBJQ0PxpseXLuinhtWN1gxAMHqT64ZMvJ4+x87p7yhzce+vhhFJMUCf0Ab7/ttjv9v1+kIn//lcb70xg34XBKabiJi7WH18cCX3y1N27BtvDiYwChqBOiURV7oj/ONN6/Ep8bpyXlo8Dp419VdJd1UZwrTNHnuuee45557Zj3GfOGiGPe5aro/9alP8eCDDwKWCOJUs2KllTsYDOJwOCq6WIIgTLkXt911m1ZqG3Xxql2M7mYfnXVu/vA7LzAYy42v4iZXr6jn71+/jvd/70XOhNJ4nRKaYfLFh09w5+UyLlkqMK0MwyCatXS7/S6rXW4ipyIIJm6HxN/fvo5b10/uQhcjHo9TU1NTIOX4fD7q6+t5XVjg0CMnUAyTcA4ax2/oq66+GnNc67xYpCCZTBIKhUo8AoD9p3PUOK3qNEkUSGZVbl1Th9spgyDy2k1t1PtcfPiHL3IqdJZo45QENBMUTT+rbyZYXPJdpy0u+tpWP1vbXOwb1FBzKpIo8J5rlkwa2R9LKfz7072MJPJcu6Ke37+io2DMrTWWh2CfK68btNS4iEaj3L61c0bNJM71eTscjgJl+lLCBTfuc9V0P/jggzz//PPs378fRVHYsWMHt912W4m4QjHsZoA27NLNSntpsIxbUZSK49mEl3JtteK9diUcHk4ymszjHb8JLX3xGOF0nmOjKXzjuXCHJJDPK2Sdzbx9u4tvPNWLZhq4ZRFREPA5ZURRoDXgJp5VuXJZPe++umvS8sxKsLcU5fjZ/iE0wwQTDEzGUnlevaEZSRRBFJFl+ZytkADye3+L2ynglO0Mg46hqbxhrQNFyZEdOk7aMPjYRpNf9co8MaDjlAQkUeDKTh97BzOkxj8je4KxuQIC8I41ArdetoqoYrKq2VdIDdrN+uzPN6lovO+7+4mkLcruC/0xhuJZPvFKSw3l9ZtaeeTIGKdDaURBwOuQ+fObVxLuOTzpvTcbPPvss1xzzTVzNt5c4oIb97lqug8fPswrXvGKAgVy8+bNPPzww/z+7/9+xeeXr9zBYJCmpqaSQFgxJusLJooiiUSi5Ca399x2ZHSy/bstRFCuuCmLIrVuhyXpIwuYholuGNTU1PCtJ86Mv8YKknXUukjnDbxOCQNLDulPb1jO6pbprwiGYRCLxUoaEKTzGnf94iiHhlMI41FiQbT0z29a2zztscHyXrY2wZPDlrKMYQq4HBK3X9nN+gr5+R2aRs9oglOjKWpd0OUXGEtk+fwTo4ykNJR8Hk2Ft611sHfvXhwOB8lEglVLanHVu3A68/x8Xw9ffXqITN5gbYuPpKIzFM8RcFsejh3IM0yTn+0f4c6bupFEAbdD4utv3cTz/XEUVWdTZ4CASyRUIb15Pti5c+eUhU0XExfUuKdT071lyxY++9nP8olPfIJMJsPjjz/Ohg0bJn1+sXGbpllQPa1k3JqmTdoXTJIkBgYGJrTxtVduSZJKXPJig9/QXkNXnZvecAabPP7yVQ3UeR3c9Zo1fPq+I6iagabrXNnp5XQ4SzKnFRrRK5pBwO3A7TCIZTRMTD5248oZGTbAU4f6+P4xge/3HeRNW9q4eV0zX3r4JLt7ouPXDIYADeN7/Zmqj4TDYd6xrY32oINfHhrFIQlc393IkZEkWVXn+jJFVVmWWd3RwOqOs+qnS4Afre3m0aMhYhmVzZ0BNnUG0HWdoaEhJEmipqYGRVE40BfmH34zimkaCKYlaiEKUOOAUFIjr4MkGEiiWMhbZzIZvB43kiThlMWSYJldYzCXePbZZ/nkJz85p2POFebcuO2a7uJ6bph+Tfett97K3r17ue6662hububaa6+d1B2GUuOORCL4/f4Jqqc2hoeH8Xg8kwoaptPpCW18baabfQ05VeczDx7j8eNhXJLIn9ywnNdsbKGj1mKgOUWBN2xu5cM3WFJO16yo5zt/uI1jwRTBvlPcft1Gvr5zuOS8Nnflvz+wnVAqT41bPieDrBxHR1J86qEzGKaIIKq80B9H1Q1290SRRZGARyaZ0ywDUHVuu6yVbVOoolRCMBhk2bJlfHhtgA+/YgVf+OVxfjIul+yQRN60pY1P3jK5SGBeM3jkyBiJnMrlS2pLuPSSJJFMJlmyZEnhO9g1OoQghnDLlnyToKkYgNPlRDaswJyigSRa26ZXLHVz+tTJksaIxS2QEokEtbW1jI6OlgQNp7q/poKiKCQSiUkDtxcbc27cRTXdJRY03ZpugE9/+tN8+tOfBuAd73hHoZSzEooVUPv6+kqeW+wmG4bB8PDwpH3BFEWhtbV1AvvIMIySQNo9j57iieNhHCJohqUX9oO9A4wm8+Q1nYhm8n+f6ePEWIYvvXE9PpdMZ52beqfB0bQDn8/Hreua+cWLwyRzGvr4+K/d2IosirQF3BOubTr4n+cHyOsmXpeIppsomsF3nu2n1iMzHFdwyxKSBxTN5G3bO/j4zd0zYlXpuk4qlSqw/foiWR48OIoogEuWMEyT/9k/zLuvXlLRI8hrBu/97n5Oh9LjKUGRz79+LTevs7YGpmkSj8dL0pP1XkchQGmnG61sv6WOWuOWecWqRlKKztUr6njHlV0TpJiK1UzD4TBer7fQIdX+qTQRVJI1djqdJdmS559/flIS1KWAC+aWT7emW9d1YrEYjY2NHDhwgAMHDnDrrbdOOq4dUEsmk0iShM9niePZtE77gw+FQgWXrLx4xNZWa2go7eRh67j19vbidrtxOp08fTKEtcMWkUSLtNEfzeGUBBTtLK1x1+kIn3voOP/wJmtLMTg4SGenJVqwdUktW5fUWi1rDROnbLKrJ8I7r5p4c04XmUxmnDuuWrxu4NRYhn9+y0Y+9fMj5HUDEYE1rV7+5IYVheDUdBEOh2lqOqsxllI0q3xy/P/iuPJoUtFo5axxD8ay/Meufo6MJDk2YkkwOSQRzTD50q9OFow7mUxOaOp449pGfvJCDYeHk5hYNFZZEq33IsDbr+zko2USS+Ww1UxFUURyujH9TbT7XRV7qNkTQXHWIJVKVWyVfN999/HUU08RCAT4u7/7O974xjeWSHRdCrgk8tz79u3jG9/4Bt/85jdRVbUQoAgEAnzve9+bsprIdsvL01s2v9xecfv7+9mwYQNDQ0MTVu5gMFgx563rOps2bULTNPL5vLWfkwzGNB1TtNhopmFNAopBoRTRgsmu0xGy2SyyLBMKhejutvjc0YxF4/Q5xUIxy4sDCQ4PJ2fd2mZbfZ77DWFcnsiCZpj0RjJ85w8u5/n+OF6nxI1rGqfkpU+GYDBY8vkub/TicYqWdpxkVa01+pwsrT/7OQYTCu/41vOkFA1tnNMN42k0wZogbFRKi8qiyNfftomnTkRI5DS2dAUIpfL0RrKASW84y72PneaNW9tYNkmzAxuPHxrgs4+n4YnnMIG/v30dr1xXGlCciazxpk2b+IM/+APe+9734nQ6C4vKpYSLZtyT1XS73W4OHz487XHsDzaXy1Fbe3YPWcwui8fjuFwuPB7PBAkmuyFgTU1NyXH7tYFAoGRP9tk3NvLhH75U4Ggvr3exssnD48fCYFiN6GTRWr29ssnx48dJJpPous6ePXusvaUug2ExuARRKLiZiXQWw/DPuCoplUqxssFFo88gnFYAwdJKN0z6Ijnett3L8vNolWO75MXpQ69T4htv38Knf3GE/miWNS1+vnD7+vFOIBYeOhQkmbMkpQRANUyyqoFTtqSiiivbwuFwxRSVLIrcuPas0S9v9OKQBP74BwfIqdb39ePnhvjuH15eImmc1wz+5ckedp6O0lTjZF9PGM0UkCUT3TD5m18cZUtnYNZte91uN319fbz5zW++ZKvILomV+3xhK4iU75dtY+3v7y/cOOWCDfF4HI/Hg8PhmFA0ABPTXxs7AvzofdvYcyaG2yFyw+omnLLAj/YO8q9P9ZLN6zgkS7zh82+4jC3L63nuuedYv349Xq/XaninKCzZf5DeaBbBNDEME5ckIMSH2Levt4QNV6mtjf3bJuoMDw/T0dHB5UvGeOpkpBCgk2WRjR2VBSBmgnKX3MaKJi8/eO8Vk77uud4YOc0kp+mIgkVk0cfr0a/rrudz4x04c7kckiRNO0X19SfPoKh6QVc9m9f5j139/P3tZ1OAf3P/UR4/FkLVTY6PplB18DrPKq9IokBvJDtr4z527Bhr1669ZA0bFoFxRyIRnn/+eTZu3Fhy3F6hs9ks+Xy+sOqUr9z9/f0sW7aMcDhcYtyV0l82Ous8vGlrqev2rquX8JYrOnjsWJi0orF9WR3LG72k02kEQSjkzmVZxi/L/Pu7L+dzDx3n8HCSJfUe/va1a0pcS1vVtFJrm3Iuua3cescKJ6eDIkNJS6fttevrePkyL/l8HofDMevAT7lLXo68ZvDNnb0cHEyyusXHB1++jBPBNLt6Ymc/T9Pi1n/4huX8yStKm0KEQqGKTMXJkMnrhZSjBZN0/qyLb4lRjCFgGbIJmLqJqps4ZWvroulGScHITLFr1y5e9rKXzfr1FwIL3rjvu+8+/H7/hH25vUIPDAzQ1dVVctxWQM1ms4XWQtFotKIe+UzgkiVuu6w0LVIcSCtGg8/JP79l44TjNgRBwOFw4HA4ptzPRSIRRkZGWLVqFfl8nn9flmMklkEwNJxo9Pb2FiaC4nHLvYDiv4sb3VVyyYthmiYf/fFL7OuLoWgGu89E2d0T5TWXtWKapkU7NUxLFFIQ+NDLl08YIxQKsXr1aiLpPPsHEvicEtuX1U0aXHz95lZOjKZQx3uLOWSR1208Sye1e40xPqFohjGusWapuWi6yUdvXE5n3fkZ98c//vFZv/5CYMEb9x/90R/x1a9+dQI7zC77jEajJQ3ait3ywcHBguEXr+iT8chnCsMwCIfD89ogzhaHtA3U7/fTPMUiaBgGqqqWeAS5XK6kusyWPi5Wrjl16lTFiSCYVNnXFyOvGYiCgKoZ9IQyhDN5VN1ANy2jkgVoqXFOiNLruk4ul6M/afIH334WE6tYZF2bn//37q0VC0Z+f1sHimbwo32DSILA+1+2tBB1B2u1ftsVlp6a3VwQwOuU+ezr1rK21U9X/bmDZpPBNE0OHjzI1q1bZz3GhcCCN24Aj8dDLpcriXKKosjY2Bjt7e0TjF7XdTRNIxKJFCSYynnkU0Xop4vR0VGam5vnbV+m6zrJZLIkkHgu2Llcl8tVUf+sGIZhcODAAVpaWgr68JlMpqTj5XBSHafoApjjq6XOf+8bwLYrYzyN8PevXzfhHJFIhIaGBv7qviOF6LkJHBpO8tMXhnnb9olejyAIvOfqJbzn6iUT/mfjL27p5sfPDWJfhDgu9jCazHPzutkbNlhkqObm5jmlsc4HFoVx2+mwcuOORqMTCDDFfcFaW1tL+oLZcruCIMyJQQ4ODk5JnT1fjI6O0tLSMm8kCtM0yWazEybIYhimyQ96nuNYMI2qG0iSQI1LIpUv5RJIAoyeOcruUSv4aa/8dheYoVi2kEoUsDTHB6Yh3zwZCvJIRcd00wrunS927tx5ye+3YREZdzqdLmnwl8lk8Pl8E1Zge+W2JZZs2NH1Srpps4EdSJtOznS2GB4eLikSmWuEw2EaGxunnDxEQeCb79rKP/76JAeHknQ3+bh9Syt3/vch4KwhCYLA1duvoDXgKgkUjo2N4fF4WNXg4MURvbDauyRwp4Ps2xermCkozxhUwqs3tPDQwSB53XL1HaLIDRW6m84UO3fu5I477jjvceYbi8K4PR4P2ezZWd6mMpbTWuGsSkttbW2JEdvGXS6AN1sU7+fnA7lcDl3Xp1WmOVucK0puw++S+ezrzk4yumGytsXH4ZEUimZYKcNVjQVaql3xp+s6tbW1LF26lHvf0cb7v7efnlAGw4R3XtXFn9y8soQ+OlnGwI4LFAcKnU4nf3xFLYnIGIdiIvVeJ3/96tWsbDo/soktzvCP//iP5zXOhcAFNe7PfOYz/Pu//zvNzVbw44tf/CKvec1rJjzv4Ycf5mMf+xi6rvP+97+fv/qrv5pyXL/fX+CXg5W7djqdFWd0URRJp9MT3HV7RZ8s/TUTXIhA2sjISMW67bnCuaLkU0ESBb71nq18e3c/J8cybOkMVNw7j42NFe6FRp+Tn37wSiIZFbfjrPSyKIrnzBjAWapweaDwjpUmf9xYZ00Ew8fYPV6zM1mmwP67OGNQjEQigSRJsxZn0HWd7du309nZyQMPPDCrMaaLi1LPPVWJnK7r/Omf/im//vWv6erq4sorr+T222+fdtknWLnr5ubmik3/7E4WlW6WbDZLKpXC7XafV0P1YDA4r4E00zQJBoNs27ZtXsaH6bnkU8ElS3ywTIK40jmKI86CIBQEHGYKQRBKMgZgBetaW1snbF1mmjGwDf7IkSM89dRTNDY28vTTT9Pd3U1HR2UNuslw7733sn79ehKJxKze50xwybnle/bsYdWqVYUo9tve9jbuu+++cxq3vXJnMhlUVcXv9xOJRCY8d2RkpGJJqNvtpqamhuHh4QnSQsVMsUq/ywkiQ0ND8xpISyaTBVbdfGF0dLSktn2uYXcJmc/3EA6HJxQDwcwzBvb9EI/HicfjBAIBfvKTn7B9+3be/e53T/t6BgYGePDBB/n0pz/N//7f/3vG72emuODG/bWvfY3vfOc7bN++nXvuuWdC8fzg4GDJTdXV1cWzzz475ZjFUku24EKlNr6qqpJKpSasqIZhIMsyq1atmvC/SkwxRVFIp9Ml+0AbkiSRzWYZGBgo3EDltcPnu6efTEpprmAYBslkclYu+XRhU1rnE9FolOXLl5/XGKIoFtpRXXvttXzuc5/jxz/+ccV4zrlw55138uUvf/mCySBfULGGD3/4w9x1110IgsBdd93FJz7xCb71rW+d9zltt9zWG1+9ejWpVGqCcQ8NDdHR0cHwcKlYwlTpr+kyxcAyiqNHj9Lc3Izf70dRlAl54Uq1w5P9rnQ9hmEQiURYvXr1TD+maeN8XfLpYGxsrFAlNx9QVXXOPQNFUYjFYrMSV3zggQdoaWnhiiuu4Iknnpiza5oK5zRuQRA+BHxo/GEtcMY0zRsne/5kYg3l+MAHPsDrXve6Ccc7Ozvp7+8vPLYb9U0Fv99PIpEoGK8gCBM0xw3DIBgMcsUVV5QYt62RNhc3gR2lX7du3Tn32+VRYFvVw+46Wh4Fto1eVVVcLkvFszgdNJeGGAwG59Ult/nw81kmGY1G51xSaf/+/WzdunVWn/UzzzzDL37xCx566CFyuRyJRIJ3vetdfO9735vTayzGOY3bNM1vAN8QBMEBPAbMerNQ7E7+7Gc/m1DsAXDllVdy4sQJenp66Ozs5Ec/+hE/+MEPphzX5/MRDAYLxgsTC0TGxsZoaGiYwBe3aatzYRwzYaRNt3bY3hbYBn/ixAnq6uoIh8OFSaE8+DOVN3Au5t2FcMmj0SgNDZWbCM4VwuHwnMkX29i1a9esxRDvvvtu7r77bgCeeOIJvvKVr8yrYcPM3PJ7gcdM07x/tif7y7/8S/bv32/VQS9fXujFPTQ0xPvf/34eeughZFnma1/7Gq961avQdZ33vve9lLv45fD5fLjdbhobGwvGW17aOTAwUDHINVX110wxODh4zmudKYq3BaqqYpoma9asqWgYxcEfezKwtwXlSiKSJFU0fpsDUM7Vn0sUp8DmC/F4nLVr187pmLt27eIrX/nKnI45n5iWcQuC8IfAMuAj53Oy7373uxWPd3R08NBDDxUev+Y1r6mY/54Mbrebl156iT/4gz8oHCteuROJBE6nc8IqOdvqr0pIpVKF1Xi+EAwGaWtrm1xiuSj4cy7YQcLiiSAejzMyMoLT6WTv3r2TkkOKA4VT5YQrwTTNirTguUQul5s0ZjFbGIbB6dOn5yTWsWPHDnbs2HH+F3UOTGfPfQXwSeDlpmlOVBa8BHDs2DEOHDhQkuIqrmjq7++vuIecq+ovmLy0cy4xPDzMpk2b5mQsmyVWzHAzDIOxsTGuvPLKgrFWIocoikIymSw8rpQTnux3NpvF6/XOq8iBXYwylzh+/Dhr1qy5pMUZyjGdlfsjQAPw+PgXvs80zffP61XNED/96U8npIZs41YUhWw2O6Fyyia4zEX1l67r8x7BzmQySJI0rVV5trDzwsWrcCVyyGSwtwXlKcPibUEmk0EURfbu3XtO7sBsDSkSicxpVxFYGOIM5ZhOQO2PLsSFnA/uvvtuvvzlL1f8nx1tLy/71DSt0A/sfGFXZ83nrD7fuW04/yj5dLYFe/fuZcuWLYiiWMITsNNMxcdsz2syimilbYFpmgUl1bnErl27+OhHPzqnY843LjmG2mywfPnyEm65DdM0CYVCXHnllSXH7fLOyZoXzBTzEUgrhmmaBXd5vnAhouQ22cfptCimsixPmzNe7A3YacNyqqi9xdJ1ndOnT1f0CmYTXzFNkwMHDsyK7tvf38973vMegsEggiDwwQ9+kI997GMzHmc2WBTGXd4M0IamaXR0dExYUW1N87lYaS9EIC0ej+P3++ck8DcZKrnk83GOmbLSircF54JhGPT09GCM92Ozu5UWewfFlOKp4gNOp7PwWYyMjNDY2DgrLoQsy9xzzz1s27aNZDLJFVdcwS233DKv9OTCuef9DBcAldr42jN+JVdWFEX6+/upqamZEP2dKSFkvks7wUoVXgiXfL7fx9jYGCtWrDj3E2cJu5nj2rVrpyyFNU0TXddLvIHiUlL7McAjjzzCr371K0zT5K//+q+5/vrree1rXzvta2pvby98dzU1Naxfv37eRTxsLArjliSpsD+zEY1GCxHhYhiGwYoVK1BVteDu2TzxSoSQ8rRP8d+mac57IE3X9QltduYatks+E7mm2ZwjnU7Pax9rwzAmyG1VgiAIhXvjXNuC7du3Ew6H2bZtG93d3ef1GZ05c4YXXniBq6++etZjzAQX3LinW9P93ve+t8DHPXjw4IzPMzAwgMfjQdf1EgPXNA23233OvWWlyG8ymSQcDpccMwyDF154YYJrN9s8cDls2d/5dpfn2yWPxWLU19fP6znsRn9zeQ5Jkti/fz/33HPPecUjUqkUv/d7v8c///M/z2tcoxgXZeU+V003wB/+4R/ykY98hPe85z3TGrN45c5kMui6jtPpnMAvt2ftc2E6kd99+/Zx2WWXIcvyhIBPpTywKIpTTgKViBdDQ0Pz6hnAhXPJ57sKbD7y28lkEkEQziv6rqoqv/d7v8c73/lO3vzmN8/h1U2NS9Ytf8UrXlHScmgmsLXKx8bGJrQImivxw/JA2nSCLXbDwfKob3H6x56MHA4HsiwXvIVUKjWptvj54EK45MAEien5QCQSmfNJau/evVx99dWz/qxN0+R973sf69ev58///M/n9NrOhYti3Oeq6Z4NiqWJ7bLPSCRSMG67+msuSCvAhGYH073G6RaL2N1F7SBfsVKIoigFEk6x8MBkUd+pJrML4ZKn02ncbve8Rvt1XS94a3OJnTt3cv3118/69c888wzf/e532bRpU0F1ZrKt6FxjXoxbEIRHK+V957Om206HRaPRAv+6uHjEdtvnYtXWdZ1oNDrnhQk27GBeNBpl69atU96wxaWjxRzx4nhBMRmk3PjtMlmb1DMfuBCFItFolLq6ujkf93zJK9dff/2EYO+Fwrx8m+M13ed8R5PVdM8GttTS8PBwgWxQ3kVkrhhpwWBwXvXCgYIbfq6VaCalo3Z2oJgKagv+9ff3l1SMVfIEKuWAp4NQKDRnnPjJEIlESqSt5wL5fJ5IJDLvacj5wgV3y6dT0z0b+Hw+xsbGqKurK6xAxa66LeAwFxgcHJz3m3Wu6abFZBA7OGR3ZCn3QOwccHF8wKaG2ulCuyS0Eh20+G/7858rNuBkiEajBd29ucKLL744a3GGSwEX3LinU9MN8Pa3v50nnniCUChEV1cXn/3sZ3nf+9436bher5dYLFZCESxuHTRXNdupVAqHwzGvBRw2bXY+ZYjA4sRXqmSTJAmv13tOTXTTNCekC8vrx3O5HIZhsG/fvikngfNRk8nn84iiOOfbivPdb19sXHDjnm5N9w9/+MMZjSvLMk8//XTJl2FzyOdy1Z6O7NP5IhKJUFtbO6+FKIZhkEgkzospJQhCwUgnw0svvcTSpUvx+XwVGWHlIpOVykbPxQ+fjxQYwO7du/nSl7405+NeKFyyqbCZYv/+/RNWOkmSCkJ5c2Hc8x1IszE8PDzveWfbIObT5TQMo9DYwOYXTEdkspgLrigKqVRqAnEIzkpOp1Ip6urqGB4eLpkQziddaBgGJ0+enPV3PdPGGvOBRWHcsViM0dHRCWQPu7RzrlbtYDBIa2vrvBqEpmkXJO8cDAbn3QOJx+MzZoxNV02mWHL6hRdeoLa2tqRQpJhKbJOHpqITl3tJJ0+erCh1PR3MprHGfGBRGHddXR0f/OAHK1aGJZPJQrO5Yu3w2eBCBNLmu3MnzI1LPh3MZwrM1pbTNA2fzzdl549iKrHtAZRTiYvJQ48//jjPPvssgiDwgx/8gK1bt87os5pNY435wKIwboCGhoaSZoBgRdBbWlrIZrPE4/HCl1vu1pXP5JVYYMlkct4DaWC55PNZJAIXxiW3zzPfQcHJuooUY6begN/v58UXX2Tjxo0MDQ0RCARmZJizaawxH1g0xu33+wmFQoXHhmHgcDjo6uqq6FqVSwaXiwCUs8Dy+Tw+n4+enp4JE8Fc6YbncjlM05zXzp1wYVzyTCZzXl7SdBGJROYsBWZ7A2vWrOHkyZP88Ic/nHPG24XEojFun89HX19f4fG5xA+LJYPPhXw+z969e1m2bFmBCFKc7qkU6Z3u3q4Yw8PDs2pTMxNcKJc8FArNOyvNNE3S6fScNzcIBoPU19fP2rBn01hjPrCojNvec8+lZDGcJXucy/0r39vZ1WGhUGjaVNBNmzYVWgnPBy6USz42Njav0lNgcQ78fv+cv5fzFUOcTWON+cBFMe7p1HTPVHuqWGpprhlpttGdCzPZ2xVTQW1PwDRNenp6KsYFJvMIZpruuRAuuaZp6Lo+7/GJ6ey3Z4Ndu3adFy16No015gMXbeU+V033TLWnilfuuaz+SiaTOJ3OOb1RK1FBk8kka9euLXFlZxoXmGo74HQ6MU3zgrjk82V05YhEInMefDRNkz179vCFL3zhvMaZaWON+cAl65bPVHvKNu7iLppzgQuxXzIMo2IXjpnEBco1wWxvoJgRZq+o+/fvnzJLcL6f3djY2Lw2EoSzW6C5FqZMp9OYpnnB1FIqYe/evbzvfe9jz5496LrOVVddxY9//OMZ12FcNOOeSU33dLSnio17rqq/dF0nFouxbt268x5rKtgr3flc83T44IcOHaK9vR2v1zsh5ztZXGCqAGGlbY+tGz7fxmETZOYae/fu5aqrrrqoxSI26eVv/uZvyGazvOtd75pVgdW8GfcrX/lKRkZGJhyfaU33dLWn7JLPudxrj4yMTNmba64wPDx83k3iz4XiKLkgCDOOC0zVVLBYJtgwDGRZJhKJzAkNdDLMF598165dl0SxyN/+7d9y5ZVX4na7+epXvzqrMebNuB999NFpPW+qmu6ZaE95vV5SqdScySiBFUjbvHnznIw1GVRVJZvNznmHjHJEIpEZCRRWigtUQjENVFEU+vr68Hg8BfbXuVRjZlsnPh8tg8CqBPvwhz885+POFLa0lqqq5HK5WaX7LopbPp2a7plqT7lcLgYHB3nkkUfo7Oykra2NlpaWWQfW7EDafNchXwi+un2eqSias0VxXMDn83HixAk2btxY8XM/V1ygvE58sknAlrKeTZOAqaCqKqFQaE4+p7/4i7/g/vvvx+l00t3dzX/8x3/MSCnmj//4j/n85z9PT08Pn/rUp/ja174242u4KMY9nZrumWpPSZLEbbfdxqFDh/j1r3/N8PAwwWCwUDjS0tJCW1sbra2ttLe309bWRltbG+3t7bS2tk64Ufbt2zfvPHKY286dk+FCEVey2WxB2LESplsnPpmsdCgUIp/Pk0ql0HWd3bt3F9oLT+YRzGSLduDAAbZs2TInE+0tt9zC3XffjSzLfOpTn+Luu+/mH/7hH6b12u985zs4HA7e8Y53oOs61113HY899hg33XTTjK5BmEd9p4sjHFUBmqYxNjbG0NAQw8PDDA0NFf4eHh5mZGSkUBra1NREY2MjzzzzDH/2Z39GR0dHyWQwlyt5JpPh6NGjs+pBNROEw2HGxsbmPTBos7LmO1J+7NgxmpqaaGhomBAXKOYOTBYXqDQJ2Lnp2tpaPvShD83p9f7sZz/jJz/5Cd///vfndNxxTDoTXbKpsLmELMslqbXJoOs6oVCIr3/96zidTurq6jh16hRPPfVUYSKwqaaNjY0Fgy/+sSeC6aRoLkTnTrBc8gtxnrGxsXkvegGrxHfVqlWzjgvYhl9cJ/7Zz36WI0eO0NzczCOPPMJHP/pRbrzxxjm53m9961u89a1vnZOxZoLfCeOeLiRJorW1lY0bN/Inf/Ink/K8DcMgEomUrP69vb3s3r274BnkcjnAKkctdv/tv1taWvjMZz4zqTLNXMEwjHlvRwSWd6Sq6rw2RARQFAVZlmfkbpfHBSrh5z//Oddccw3PPPMMo6Oj00rlTZUResMb3lD4W5Zl3vnOd077eucKvxNu+cWCaZpEo9HCBGBvB4aGhjh48CC9vb2FFae2tnZKT6CmpmZWe8EL5ZKPjo4Sj8fnvTvK8PAwuVxuzhsKnjx5kk9/+tPcf//9czbmf/7nf/Jv//Zv/OY3v5nPSr/fbbf8YkEQBBoaGmhoaJjALb7zzju56667uPHGGwu00GJPYHBwkAMHDhQmhWQyiWma+P3+EqMvDhC2t7dPUD559tlnL0jjubGxsQtS+TQfXUXASoGdT7FIOR5++GG+/OUv8+STT857Ce9kqK7cFwmapk1ZkjoZkslkRU/APhaLxQDweDy0trayZ88ePvjBD5ZMAG1tbXNaGWaaJrt37+aaa66Z15TefJ7nwx/+MB/4wAfmjMCyatUqFEUpaKlfc801fOMb35iTsctQXbkvNcw2/15TU0NNTc0EHno50uk0//Vf/4UoigVe/tNPP12YFCKRCGDxA4q3AeWpwqampnNOQIlEYtbbhpkgk8ng8Xjm/DymafLiiy9y5ZVXztmYJ0+enLOxZouqcS9S+Hw+1q5dyxVXXDElyy6bzTIyMlLiCdiBweHhYUKhEKZp4nQ6CwHB8p+f//zn7NixY97f03x0FQFrSxEIBOadsHShUXXLq5gWFEUpTAJ2TMD++/7772f58uWFfmMtLS0TsgP27+bm5ll7LS+++CKrVq2ac+WV++67jwMHDnD33XfP6bgXCFW3vIrzg8vlYtmyZSxbtqzk+OjoKAMDAzzyyCOAReEMBoMlnsCBAwd4+OGHC6xBW2mmubl50uxAOWtQ0zSOHz8+L1z/Xbt28epXv3rOx73YqK7cVZw38vn8jPXGNE1jdHS0oicwNDREMBgsYQ0GAgEGBwd5y1veUhITmAvW4E033cTDDz88L11CLwAmXbmrxl3FJQ2bNfjFL34Rh8PBunXrChOATR1WFKWQdqxEGLIngUoEm3Q6zW233cbevXsXasO/qltexcKEzRq89tpr2bFjx5SswXA4XLL626xBeyIoZg3aRp9Kpeju7p5Tw77nnnv45Cc/ydjYGE1NTXM27kxRNe4qFgTe9ra3Tfl/URRpbm6mubl5yn15MWtwaGiI5557bk7Zbv39/TzyyCPzUms+U1Td8iqqmEPccccd3HXXXbzhDW9g3759F2LlntTlmL8esVVU8TuG++67j87OTrZs2XKxLwWouuVVVDEjTFUJ9sUvfrGQErwUUHXLq6hiDvDSSy9x8803F4pEBgYG6OjoYM+ePfPdIqqaCpsOdF1n+/btdHZ28sADD1zsy6liAWP58uXVPfelhHvvvfeCKIlUUcWFQNW4xzEwMMCDDz7I+9///ot9KVUsApw5c+ai5rihatwF3HnnnXz5y1+eM83zcvT393PjjTeyYcMGLrvsMu699955OU8VVdioGjfwwAMP0NLSwhVXXDFv57AbGx4+fJjdu3fz9a9/ncOHD8/b+aqoomrcwDPPPMMvfvELli9fztve9jYee+wx3vWud83pOdrb2wsSxsWNDecaDz/8MGvXrmXVqlV86UtfmvPxq1hAME1zvn4WJB5//HHzta997byeo6enx1yyZIkZj8fndFxN08yVK1eap06dMhVFMTdv3mweOnRoTs9RxSWHSW2wunJfYEy3seFssGfPHlatWsXKlStxOp287W1v47777pvTc1SxcFA17jLs2LFj3nLcM2lsOBsMDg6WdPvo6uqaF9e/GH/xF3/BunXr2Lx5M29605sKAo1VXHxUjfsCwZxhY8OFgltuuYWDBw9y4MAB1qxZs1ClihYlqsZ9gWA3NnzsscfYunUrW7du5aGHHprTc3R2dhb6dYGVu59vLfFbb721oIl2zTXXMDAwMK/nq2IGmGpDfp4/VVxgqKpqrlixwjx9+nQhoHbw4MELdv7Xve515ne/+915PcdXvvIVEzDHxsbm9TwLCJPaYLUqbBHB7lT5qle9Cl3Xee973zuh08lscKn0xLqUhBAWAqqFI1WcNy5QT6yLIYSwEFDVUKtifnChemJdakIICwHVlbuK88Jc9sSajhBCbW3thSynXAio1nNXsXBxEYUQFgIuinFXUcW8QBCEM8B20zRDF/taLmVU89xVVLFIUV25q6hikaK6cldRxSJF1birqGKRomrcVVSxSFE17kUAQRA+JwjCnUWPvyAIwscu4iVVcQmgGlBbBBAEYTnwU9M0twmCIAIngKtM0wxf3Cur4mKiSj9dBDBN84wgCGFBEC4HWoEXqoZdRdW4Fw++Cfwh0AZ86+JeShWXAqpu+SKBIAhO4CXAAaw2TVO/yJdUxUVGdeVeJDBNMy8IwuNArGrYVUDVuBcNxgNp1wBvudjXUsWlgWoqbBFAEIQNwEngN6ZpnrjY11PFpYHqnruKKhYpqit3FVUsUlSNu4oqFimqxl1FFYsUVeOuoopFiqpxV1HFIkXVuKuoYpHi/wM4Cc2/wXM6jQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "x_side_sampler = tp.samplers.RandomUniformSampler(Ix.boundary*Iy*Iz, n_points=200)\n", - "\n", - "y_side_sampler = tp.samplers.RandomUniformSampler(Iy.boundary*Ix*Iz, n_points=200)\n", - "\n", - "top_sampler = tp.samplers.RandomUniformSampler(Ix*Iy*Iz.boundary_right, n_points=300)\n", - "bottom_sampler = tp.samplers.RandomUniformSampler(Ix*Iy*Iz.boundary_left, n_points=200)\n", - "\n", - "fig = tp.utils.scatter(X*Y*Z, bottom_sampler)\n", - "fig.get_axes()[0].view_init(30, 190)\n", - "fig.set_size_inches(6, 4)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0000163639338897\n", - "tensor([[[[1.2857, 0.0000, 0.0000],\n", - " [0.0000, 0.8572, 0.0000],\n", - " [0.0000, 0.0000, 0.8572]],\n", - "\n", - " [[0.0000, 0.2143, 0.0000],\n", - " [0.2143, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.0000]],\n", - "\n", - " [[0.0000, 0.0000, 0.2143],\n", - " [0.0000, 0.0000, 0.0000],\n", - " [0.2143, 0.0000, 0.0000]]],\n", - "\n", - "\n", - " [[[0.0000, 0.2143, 0.0000],\n", - " [0.2143, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.0000]],\n", - "\n", - " [[0.8572, 0.0000, 0.0000],\n", - " [0.0000, 1.2857, 0.0000],\n", - " [0.0000, 0.0000, 0.8572]],\n", - "\n", - " [[0.0000, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.2143],\n", - " [0.0000, 0.2143, 0.0000]]],\n", - "\n", - "\n", - " [[[0.0000, 0.0000, 0.2143],\n", - " [0.0000, 0.0000, 0.0000],\n", - " [0.2143, 0.0000, 0.0000]],\n", - "\n", - " [[0.0000, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.2143],\n", - " [0.0000, 0.2143, 0.0000]],\n", - "\n", - " [[0.8572, 0.0000, 0.0000],\n", - " [0.0000, 0.8572, 0.0000],\n", - " [0.0000, 0.0000, 1.2857]]]])\n" - ] - } - ], - "source": [ - "# Compute C:\n", - "def delta(a, b):\n", - " return a == b\n", - "\n", - "C = torch.zeros((3, 3, 3, 3), dtype=torch.float32) # Tensor 4. Stufe R^(3x3x3x3)\n", - "for i,j,k,l in itertools.product(range(3), range(3), range(3), range(3)):\n", - " unit_prod = delta(i, j) * delta(k, l) #Kroneckersymbol berechnet; \n", - " P_sym = 0.5 * (delta(i, k) * delta(j, l) + delta(j, k) * delta(i, l)) - 1/3.0*unit_prod\n", - " C[i,j,k,l] = kappa * unit_prod + 2*mu*P_sym\n", - "\n", - "# reshape to (9, 1, 3, 3), to apply to batch of the form (\"1\", batch_dim, 3, 3)\n", - "print(kappa)\n", - "print(C)\n", - "C = C.reshape(9, 1, 3, 3)\n", - "#print(C)\n", - "if torch.cuda.device_count() > 0:\n", - " C = C.to('cuda')" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([[[3.8572, 0.2143, 0.4286],\n", - " [0.2143, 3.8572, 0.6429],\n", - " [0.4286, 0.6429, 4.2858]],\n", - "\n", - " [[7.2858, 0.4286, 1.5000],\n", - " [0.4286, 9.0001, 0.6429],\n", - " [1.5000, 0.6429, 7.7144]]])\n" - ] - } - ], - "source": [ - "## test C stuff:\n", - "a = torch.tensor([[[1.0, 0.0, 2.0], [1.0, 1.0, 2.0], [0.0, 1.0, 2.0]], \n", - " [[1.0, 1.0, 2.0], [1.0, 5.0, 2.0], [5.0, 1.0, 2.0]]])\n", - "b = C*a\n", - "print(b.sum(dim=(2, 3)).T.reshape(len(a), 3, 3))" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "# inner pde condition:\n", - "def pde_residual(u, C, x, y, z):\n", - " sym_grad = tp.utils.sym_grad(u, x, y, z)\n", - " prod = C*sym_grad #Spannung\n", - " sigma = (prod.sum(dim=(2, 3))).T.reshape(len(u), 3, 3)\n", - " return tp.utils.matrix_div(sigma, x, y, z) # + forces\n", - "\n", - "def bc_x_residual(u, x, y, z):\n", - " # nur x-Koordinate wird Null gesetzt\n", - " return u #u[:,0:1]\n", - "\n", - "def bc_y_residual(u, x, y, z):\n", - " return u #u[:,1:2]\n", - "\n", - "def bc_z_top_residual(u, x, y, z):\n", - " press = u_dis * torch.cos(math.pi/10.0 * x) * torch.cos(math.pi/10.0 * y)\n", - " return u[:, 2:] + press\n", - "\n", - "def bc_z_bottom_residual(u, x, y, z):\n", - " # auf Boden sind alle Komponenten der Verschiebung Null\n", - " return u\n", - "\n", - "pde_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=inner_sampler,\n", - " residual_fn=pde_residual,\n", - " data_functions={'C': C}, \n", - " weight=1)\n", - "\n", - "bc_x_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=x_side_sampler,\n", - " residual_fn=bc_x_residual,\n", - " data_functions={'C': C}, \n", - " weight=1)\n", - "\n", - "bc_y_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=y_side_sampler,\n", - " residual_fn=bc_y_residual,\n", - " data_functions={'C': C}, \n", - " weight=1)\n", - "\n", - "bc_z_top_cond = tp.conditions.PINNCondition(module=model,\n", - " sampler=top_sampler,\n", - " residual_fn=bc_z_top_residual,\n", - " data_functions={'C': C}, \n", - " weight=1)\n", - "\n", - "bc_z_bottom_cond = tp.conditions.PINNCondition(module=model,\n", - " sampler=bottom_sampler,\n", - " residual_fn=bc_z_bottom_residual,\n", - " weight=1)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/inu2sh/.conda/envs/TorchPhysics/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/callback_connector.py:151: LightningDeprecationWarning: Setting `Trainer(checkpoint_callback=False)` is deprecated in v1.5 and will be removed in v1.7. Please consider using `Trainer(enable_checkpointing=False)`.\n", - " rank_zero_deprecation(\n", - "GPU available: False, used: False\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "HPU available: False, using: 0 HPUs\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 5.5 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "5.5 K Trainable params\n", - "0 Non-trainable params\n", - "5.5 K Total params\n", - "0.022 Total estimated model params size (MB)\n", - "/home/inu2sh/.conda/envs/TorchPhysics/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:240: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 64 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " rank_zero_warn(\n", - "/home/inu2sh/.conda/envs/TorchPhysics/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:240: PossibleUserWarning: 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 64 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " rank_zero_warn(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "bd81fc3a94344b988177b278fe75553a", - "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": [ - "# Training \n", - "def plot_displacement_x(u, x, y, z):\n", - " # Verschiebung in x-Richtung\n", - " return u[:, 0:1]\n", - "\n", - "def plot_displacement_y(u, x, y, z):\n", - " # Verschiebung in x-Richtung\n", - " return u[:, 1:2]\n", - "\n", - "def plot_displacement_z(u, x, y, z):\n", - " # Verschiebung in x-Richtung\n", - " return u[:, 2:3]\n", - "\n", - "xy_square = tp.domains.Parallelogram(X*Y, [-size, -size], [size, -size], [-size, size])\n", - "samp = tp.samplers.PlotSampler(xy_square, n_points=1000, data_for_other_variables={'z': 0.0})\n", - "\n", - "optim = tp.solver.OptimizerSetting(torch.optim.Adam, lr=1e-3) #' Adam, Adagrad '\n", - "solver = tp.solver.Solver([pde_condition, bc_x_condition, bc_y_condition, bc_z_top_cond, bc_z_bottom_cond],\n", - " optimizer_setting = optim)\n", - "\n", - "calls = [tp.utils.PlotterCallback(model=model,plot_function=plot_displacement_z,point_sampler=samp,\n", - " log_name='ausgabe', plot_type='contour_surface',check_interval=10), \n", - " tp.utils.WeightSaveCallback(model=model,path='.',name='NN',check_interval = 10, save_initial_model=False,\n", - " save_final_model = True)]\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", - " #callbacks = calls, \n", - " checkpoint_callback=False\n", - " )\n", - "trainer.fit(solver)\n", - "\n", - "#from winsound import Beep\n", - "#frequency = 1000 # Herz\n", - "#duration = 500 # ms\n", - "##Beep( frequency, duration )" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/inu2sh/.conda/envs/TorchPhysics/lib/python3.10/site-packages/torch/functional.py:568: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /opt/conda/conda-bld/pytorch_1646755897462/work/aten/src/ATen/native/TensorShape.cpp:2228.)\n", - " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n", - "/home/inu2sh/.conda/envs/TorchPhysics/lib/python3.10/site-packages/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 /opt/conda/conda-bld/pytorch_1646755897462/work/aten/src/ATen/native/TensorShape.cpp:2318.)\n", - " bary_coords = torch.stack(torch.meshgrid((x, y))).T.reshape(-1, 2)\n", - "/home/inu2sh/.conda/envs/TorchPhysics/lib/python3.10/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_1646755897462/work/torch/csrc/utils/tensor_new.cpp:210.)\n", - " embed_point = Points(torch.tensor([center]), domain.space)\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Verschiebung in z-Richtung in [mm]')" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from matplotlib import pyplot\n", - "xy_square = tp.domains.Parallelogram(X*Y, [-size, -size], [size, -size], [-size, size])\n", - "samp = tp.samplers.PlotSampler(xy_square, n_points=1000, data_for_other_variables={'z': 5.0})\n", - "fig = tp.utils.plot(model, plot_displacement_z, samp, plot_type='contour_surface')\n", - "pyplot.title('Verschiebung in z-Richtung in [mm]')\n", - "#pyplot.savefig('Verschiebung-z-Richtung.png', dvi=360)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_90417/3194462345.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"dvi\" which is no longer supported as of 3.3 and will become an error in 3.6\n", - " pyplot.savefig('Verschiebung-y-Richtung.png', dvi=720)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "xy_square = tp.domains.Parallelogram(X*Y, [-size, -size], [size, -size], [-size, size])\n", - "xz_square = tp.domains.Parallelogram(X*Z, [-size, -size], [size, -size], [-size, size])\n", - "yz_square = tp.domains.Parallelogram(Y*Z, [-size, -size], [size, -size], [-size, size])\n", - "samp = tp.samplers.PlotSampler(yz_square, n_points=1000, data_for_other_variables={'x': 4.0})\n", - "fig = tp.utils.plot(model, plot_displacement_x, samp, plot_type='contour_surface')\n", - "pyplot.title('Verschiebung in y-Richtung [mm]')\n", - "pyplot.savefig('Verschiebung-y-Richtung.png', dvi=720)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: False, used: False\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "HPU available: False, using: 0 HPUs\n", - "/home/inu2sh/.conda/envs/TorchPhysics/lib/python3.10/site-packages/pytorch_lightning/trainer/configuration_validator.py:342: LightningDeprecationWarning: Base `Callback.on_train_batch_end` hook signature has changed in v1.5. The `dataloader_idx` argument will be removed in v1.7.\n", - " rank_zero_deprecation(\n", - "/home/inu2sh/.conda/envs/TorchPhysics/lib/python3.10/site-packages/pytorch_lightning/trainer/configuration_validator.py:342: LightningDeprecationWarning: Base `Callback.on_train_batch_start` hook signature has changed in v1.5. The `dataloader_idx` argument will be removed in v1.7.\n", - " rank_zero_deprecation(\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 5.5 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "5.5 K Trainable params\n", - "0 Non-trainable params\n", - "5.5 K Total params\n", - "0.022 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e7d5d8d2a867471c8b92ab7ad271e0bd", - "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": [ - "# Training mit statischem Sampling\n", - "inner_sampler = tp.samplers.RandomUniformSampler(cube, n_points = 32*32*32).make_static()\n", - "x_side_sampler = tp.samplers.RandomUniformSampler(Ix.boundary*Iy*Iz, n_points=100).make_static()\n", - "\n", - "y_side_sampler = tp.samplers.RandomUniformSampler(Iy.boundary*Ix*Iz, n_points=100).make_static()\n", - "\n", - "top_sampler = tp.samplers.RandomUniformSampler(Ix*Iy*Iz.boundary_right, n_points=200).make_static()\n", - "bottom_sampler = tp.samplers.RandomUniformSampler(Ix*Iy*Iz.boundary_left, n_points=100).make_static()\n", - "\n", - "\n", - "xy_square = tp.domains.Parallelogram(X*Y, [-size, -size], [size, -size], [-size, size])\n", - "samp = tp.samplers.PlotSampler(xy_square, n_points=1000, data_for_other_variables={'z': 0.0})\n", - "\n", - "optim = tp.solver.OptimizerSetting(torch.optim.LBFGS, lr=0.1) #' Adam, Adagrad '\n", - "solver = tp.solver.Solver([pde_condition, bc_x_condition, bc_y_condition, bc_z_top_cond, bc_z_bottom_cond],\n", - " optimizer_setting = optim)\n", - "\n", - "calls = [tp.utils.PlotterCallback(model=model,plot_function=plot_displacement_z,point_sampler=samp,\n", - " log_name='ausgabe', plot_type='contour_surface',check_interval=10), \n", - " tp.utils.WeightSaveCallback(model=model,path='.',name='NN',check_interval = 10, save_initial_model=False,\n", - " save_final_model = True)]\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=300,\n", - " #logger=False,\n", - " callbacks = calls, \n", - " checkpoint_callback=False\n", - " )\n", - "trainer.fit(solver)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Verschiebung in z-Richtung [mm]')" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "xy_square = tp.domains.Parallelogram(X*Y, [-size, -size], [size, -size], [-size, size])\n", - "samp = tp.samplers.PlotSampler(xy_square, n_points=2000, data_for_other_variables={'z': 4.5})\n", - "fig = tp.utils.plot(model, plot_displacement_z, samp, plot_type='contour_surface')\n", - "pyplot.title('Verschiebung in z-Richtung [mm]')\n", - "#pyplot.savefig('Verschiebung-y-Richtung.png', dvi=720)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Verschiebung in x-Richtung [mm]')" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "xy_square = tp.domains.Parallelogram(X*Y, [-size, -size], [size, -size], [-size, size])\n", - "samp = tp.samplers.PlotSampler(xy_square, n_points=2000, data_for_other_variables={'z': 5.0})\n", - "fig = tp.utils.plot(model, plot_displacement_x, samp, plot_type='contour_surface')\n", - "pyplot.title('Verschiebung in x-Richtung [mm]')\n", - "#pyplot.savefig('Verschiebung-x-Richtung.png', dvi=720)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_90417/2953493800.py:21: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"dvi\" which is no longer supported as of 3.3 and will become an error in 3.6\n", - " pyplot.savefig('sigma-x-y-z=45.png', dvi=360)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "kappa = 18333.3\n", - "mu = 3928.57 \n", - "\n", - "C = torch.zeros((3, 3, 3, 3), dtype=torch.float32)\n", - "for i,j,k,l in itertools.product(range(3), range(3), range(3), range(3)):\n", - " unit_prod = delta(i, j) * delta(k, l)\n", - " P_sym = 0.5 * (delta(i, k) * delta(j, l) + delta(j, k) * delta(i, l)) - 1/3.0*unit_prod\n", - " C[i,j,k,l] = kappa * unit_prod + 2*mu*P_sym\n", - " \n", - "C = C.reshape(9, 1, 3, 3)\n", - "\n", - "def strain_fn(u, x, y, z):\n", - " sym_grad = tp.utils.sym_grad(u, x, y, z)\n", - " prod = C*sym_grad\n", - " sigma = (prod.sum(dim=(2, 3))).T.reshape(len(u), 3, 3)\n", - " return torch.norm(sigma, dim=(1,2))\n", - "\n", - "samp = tp.samplers.PlotSampler(xy_square, n_points=1000, data_for_other_variables={'z':4.0})\n", - "fig = tp.utils.plot(model, strain_fn, samp, plot_type='contour_surface')\n", - "pyplot.title('Spannung $\\sigma$ $[N/mm^2]$')\n", - "pyplot.savefig('sigma-x-y-z=45.png', dvi=360)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Spannung $N/mm^2$')" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "x_interval = tp.domains.Interval(X, -size, size)\n", - "y_interval = tp.domains.Interval(Y, -size, size)\n", - "z_ebene = 2.0\n", - "samp1 = tp.samplers.PlotSampler(y_interval, n_points=100, data_for_other_variables={'x':0.0,'z': z_ebene})\n", - "samp2 = tp.samplers.PlotSampler(x_interval, n_points=100, data_for_other_variables={'y':0.0,'z': z_ebene})\n", - "fig1 = tp.utils.plot(model, strain_fn, samp1)\n", - "fig2 = tp.utils.plot(model, strain_fn, samp2)\n", - "pyplot.ylabel('Spannung $N/mm^2$')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " #´ß0431 ´ß098765430" - ] - } - ], - "metadata": { - "interpreter": { - "hash": "fb770cb910411e790a99fd848f827dc995ac53be5098d939fbaa56bcec3c9277" - }, - "kernelspec": { - "display_name": "Python [conda env:.conda-TorchPhysics]", - "language": "python", - "name": "conda-env-.conda-TorchPhysics-py" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.4" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/solid_mechanics/NN_final.pt b/examples/solid_mechanics/NN_final.pt deleted file mode 100644 index 2824724f..00000000 Binary files a/examples/solid_mechanics/NN_final.pt and /dev/null differ diff --git a/examples/solid_mechanics/NN_min_loss.pt b/examples/solid_mechanics/NN_min_loss.pt deleted file mode 100644 index a8a6d59a..00000000 Binary files a/examples/solid_mechanics/NN_min_loss.pt and /dev/null differ diff --git a/examples/solid_mechanics/Verschiebung-y-Richtung.png b/examples/solid_mechanics/Verschiebung-y-Richtung.png deleted file mode 100644 index 9b7ef4b4..00000000 Binary files a/examples/solid_mechanics/Verschiebung-y-Richtung.png and /dev/null differ diff --git a/examples/solid_mechanics/mechanic_cube_FCN.ipynb b/examples/solid_mechanics/mechanic_cube_FCN.ipynb deleted file mode 100644 index 764f2da8..00000000 --- a/examples/solid_mechanics/mechanic_cube_FCN.ipynb +++ /dev/null @@ -1,687 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torchphysics as tp\n", - "import pytorch_lightning as pl\n", - "import itertools\n", - "import math" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "# Spaces for in- and output\n", - "X = tp.spaces.R1('x')\n", - "Y = tp.spaces.R1('y')\n", - "Z = tp.spaces.R1('z')\n", - "U = tp.spaces.R3('u')\n", - "\n", - "# Parameter\n", - "fskal =18333\n", - "kappa = 18333.3/fskal # GPa = 18333,33 Mpa\n", - "mu = 3928.57/fskal # GPa = 3928.57 Mpa\n", - "u_dis = 0.2 # mm\n", - "size = 5.0 # mm" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "# Load stl.file and create domain\n", - "Ix = tp.domains.Interval(X, -size, size)\n", - "Iy = tp.domains.Interval(Y, -size, size)\n", - "Iz = tp.domains.Interval(Z, -size, size)\n", - "cube = Ix * Iy * Iz" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "class Sinus(torch.nn.Module):\n", - " def __init__(self):\n", - " super().__init__()\n", - "\n", - " def forward(self, input):\n", - " return torch.sin(input)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "# network to train\n", - "model = tp.models.Sequential(\n", - " tp.models.NormalizationLayer(cube),\n", - " #tp.models.FCN(activations = Sinus(),input_space=X*Y*Z, output_space=U, hidden=(30,30,30,30,30)))\n", - " #tp.models.FCN(input_space=X*Y*Z, output_space=U, hidden=(32,32,32,32,32))) \n", - " tp.models.FCN(input_space=X*Y*Z, output_space=U, hidden=(50,50,50),xavier_gains=[5/3,5/3,0]))" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "inner_sampler = tp.samplers.RandomUniformSampler(cube, n_points = 1000) #.make_static()\n", - "\n", - "fig = tp.utils.scatter(X*Y*Z, inner_sampler)\n", - "fig.get_axes()[0].view_init(30, 170)\n", - "fig.set_size_inches(6, 4)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "x_side_sampler = tp.samplers.RandomUniformSampler(Ix.boundary*Iy*Iz, n_points=200)\n", - "\n", - "y_side_sampler = tp.samplers.RandomUniformSampler(Iy.boundary*Ix*Iz, n_points=200)\n", - "\n", - "top_sampler = tp.samplers.RandomUniformSampler(Ix*Iy*Iz.boundary_right, n_points=300)\n", - "bottom_sampler = tp.samplers.RandomUniformSampler(Ix*Iy*Iz.boundary_left, n_points=200)\n", - "\n", - "fig = tp.utils.scatter(X*Y*Z, bottom_sampler)\n", - "fig.get_axes()[0].view_init(30, 190)\n", - "fig.set_size_inches(6, 4)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0000163639338897\n", - "tensor([[[[1.2857, 0.0000, 0.0000],\n", - " [0.0000, 0.8572, 0.0000],\n", - " [0.0000, 0.0000, 0.8572]],\n", - "\n", - " [[0.0000, 0.2143, 0.0000],\n", - " [0.2143, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.0000]],\n", - "\n", - " [[0.0000, 0.0000, 0.2143],\n", - " [0.0000, 0.0000, 0.0000],\n", - " [0.2143, 0.0000, 0.0000]]],\n", - "\n", - "\n", - " [[[0.0000, 0.2143, 0.0000],\n", - " [0.2143, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.0000]],\n", - "\n", - " [[0.8572, 0.0000, 0.0000],\n", - " [0.0000, 1.2857, 0.0000],\n", - " [0.0000, 0.0000, 0.8572]],\n", - "\n", - " [[0.0000, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.2143],\n", - " [0.0000, 0.2143, 0.0000]]],\n", - "\n", - "\n", - " [[[0.0000, 0.0000, 0.2143],\n", - " [0.0000, 0.0000, 0.0000],\n", - " [0.2143, 0.0000, 0.0000]],\n", - "\n", - " [[0.0000, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.2143],\n", - " [0.0000, 0.2143, 0.0000]],\n", - "\n", - " [[0.8572, 0.0000, 0.0000],\n", - " [0.0000, 0.8572, 0.0000],\n", - " [0.0000, 0.0000, 1.2857]]]])\n" - ] - } - ], - "source": [ - "# Compute C:\n", - "def delta(a, b):\n", - " return a == b\n", - "\n", - "C = torch.zeros((3, 3, 3, 3), dtype=torch.float32) # Tensor 4. Stufe R^(3x3x3x3)\n", - "for i,j,k,l in itertools.product(range(3), range(3), range(3), range(3)):\n", - " unit_prod = delta(i, j) * delta(k, l) #Kroneckersymbol berechnet; \n", - " P_sym = 0.5 * (delta(i, k) * delta(j, l) + delta(j, k) * delta(i, l)) - 1/3.0*unit_prod\n", - " C[i,j,k,l] = kappa * unit_prod + 2*mu*P_sym\n", - "\n", - "# reshape to (9, 1, 3, 3), to apply to batch of the form (\"1\", batch_dim, 3, 3)\n", - "print(kappa)\n", - "print(C)\n", - "C = C.reshape(9, 1, 3, 3)\n", - "#print(C)\n", - "if torch.cuda.device_count() > 0:\n", - " C = C.to('cuda')" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "## test C stuff:\n", - "# a = torch.tensor([[[1.0, 0.0, 2.0], [1.0, 1.0, 2.0], [0.0, 1.0, 2.0]], \n", - "# [[1.0, 1.0, 2.0], [1.0, 5.0, 2.0], [5.0, 1.0, 2.0]]])\n", - "# b = C*a\n", - "# print(b.sum(dim=(2, 3)).T.reshape(len(a), 3, 3))" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "# inner pde condition:\n", - "def pde_residual(u, C, x, y, z):\n", - " sym_grad = tp.utils.sym_grad(u, x, y, z)\n", - " prod = C*sym_grad #Spannung\n", - " sigma = (prod.sum(dim=(2, 3))).T.reshape(len(u), 3, 3)\n", - " return tp.utils.matrix_div(sigma, x, y, z) # + forces\n", - "\n", - "def bc_x_residual(u, x, y, z):\n", - " # nur x-Koordinate wird Null gesetzt\n", - " return u #u[:,0:1]\n", - "\n", - "def bc_y_residual(u, x, y, z):\n", - " return u #u[:,1:2]\n", - "\n", - "def bc_z_top_residual(u, x, y, z):\n", - " press = u_dis * torch.cos(math.pi/10.0 * x) * torch.cos(math.pi/10.0 * y)\n", - " return u[:, 2:] + press\n", - "\n", - "def bc_z_bottom_residual(u, x, y, z):\n", - " # auf Boden sind alle Komponenten der Verschiebung Null\n", - " return u\n", - "\n", - "pde_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=inner_sampler,\n", - " residual_fn=pde_residual,\n", - " data_functions={'C': C}, \n", - " weight=1)\n", - "\n", - "bc_x_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=x_side_sampler,\n", - " residual_fn=bc_x_residual,\n", - " data_functions={'C': C}, \n", - " weight=1)\n", - "\n", - "bc_y_condition = tp.conditions.PINNCondition(module=model,\n", - " sampler=y_side_sampler,\n", - " residual_fn=bc_y_residual,\n", - " data_functions={'C': C}, \n", - " weight=1)\n", - "\n", - "bc_z_top_cond = tp.conditions.PINNCondition(module=model,\n", - " sampler=top_sampler,\n", - " residual_fn=bc_z_top_residual,\n", - " data_functions={'C': C}, \n", - " weight=1)\n", - "\n", - "bc_z_bottom_cond = tp.conditions.PINNCondition(module=model,\n", - " sampler=bottom_sampler,\n", - " residual_fn=bc_z_bottom_residual,\n", - " weight=1)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "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: [3]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 5.5 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "5.5 K Trainable params\n", - "0 Non-trainable params\n", - "5.5 K Total params\n", - "0.022 Total estimated model params size (MB)\n", - "/home/krd2rng/.conda/envs/pytorch-physics/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 64 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n", - "/home/krd2rng/.conda/envs/pytorch-physics/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 64 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": "b1b6c9b9f75f4a0d9e4b8f7ae70b0a39", - "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": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Training \n", - "def plot_displacement_x(u, x, y, z):\n", - " # Verschiebung in x-Richtung\n", - " return u[:, 0:1]\n", - "\n", - "def plot_displacement_y(u, x, y, z):\n", - " # Verschiebung in x-Richtung\n", - " return u[:, 1:2]\n", - "\n", - "def plot_displacement_z(u, x, y, z):\n", - " # Verschiebung in x-Richtung\n", - " return u[:, 2:3]\n", - "\n", - "xy_square = tp.domains.Parallelogram(X*Y, [-size, -size], [size, -size], [-size, size])\n", - "samp = tp.samplers.PlotSampler(xy_square, n_points=1000, data_for_other_variables={'z': 0.0})\n", - "\n", - "optim = tp.solver.OptimizerSetting(torch.optim.Adam, lr=1e-3) #' Adam, Adagrad '\n", - "solver = tp.solver.Solver([pde_condition, bc_x_condition, bc_y_condition, bc_z_top_cond, bc_z_bottom_cond],\n", - " optimizer_setting = optim)\n", - "\n", - "calls = [tp.utils.PlotterCallback(model=model,plot_function=plot_displacement_z,point_sampler=samp,\n", - " log_name='ausgabe', plot_type='contour_surface',check_interval=10), \n", - " tp.utils.WeightSaveCallback(model=model,path='.',name='NN',check_interval = 10, save_initial_model=False,\n", - " save_final_model = True)]\n", - "\n", - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=5000, \n", - " logger=False, \n", - " enable_checkpointing=False)\n", - "trainer.fit(solver)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/krd2rng/.conda/envs/pytorch-physics/lib/python3.9/site-packages/torch/functional.py:568: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /opt/conda/conda-bld/pytorch_1646756402876/work/aten/src/ATen/native/TensorShape.cpp:2228.)\n", - " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n", - "/home/krd2rng/python/mso-036/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 /opt/conda/conda-bld/pytorch_1646756402876/work/aten/src/ATen/native/TensorShape.cpp:2318.)\n", - " bary_coords = torch.stack(torch.meshgrid((x, y))).T.reshape(-1, 2)\n", - "/home/krd2rng/python/mso-036/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 /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": { - "text/plain": [ - "Text(0.5, 1.0, 'Verschiebung in z-Richtung in [mm]')" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from matplotlib import pyplot\n", - "xy_square = tp.domains.Parallelogram(X*Y, [-size, -size], [size, -size], [-size, size])\n", - "samp = tp.samplers.PlotSampler(xy_square, n_points=1000, data_for_other_variables={'z': 5.0})\n", - "fig = tp.utils.plot(model, plot_displacement_z, samp, plot_type='contour_surface')\n", - "pyplot.title('Verschiebung in z-Richtung in [mm]')\n", - "#pyplot.savefig('Verschiebung-z-Richtung.png', dvi=360)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"dvi\" which is no longer supported as of 3.3 and will become an error two minor releases later\n", - " pyplot.savefig('Verschiebung-y-Richtung.png', dvi=720)\n" - ] - } - ], - "source": [ - "xy_square = tp.domains.Parallelogram(X*Y, [-size, -size], [size, -size], [-size, size])\n", - "xz_square = tp.domains.Parallelogram(X*Z, [-size, -size], [size, -size], [-size, size])\n", - "yz_square = tp.domains.Parallelogram(Y*Z, [-size, -size], [size, -size], [-size, size])\n", - "samp = tp.samplers.PlotSampler(yz_square, n_points=1000, data_for_other_variables={'x': 4.0})\n", - "fig = tp.utils.plot(model, plot_displacement_x, samp, plot_type='contour_surface')\n", - "pyplot.title('Verschiebung in y-Richtung [mm]')\n", - "pyplot.savefig('Verschiebung-y-Richtung.png', dvi=720)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "scrolled": true - }, - "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: [3]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 5.5 K \n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "5.5 K Trainable params\n", - "0 Non-trainable params\n", - "5.5 K Total params\n", - "0.022 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "344b8c140d82457e8352b7fa74ba5add", - "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": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Training mit statischem Sampling\n", - "inner_sampler = tp.samplers.RandomUniformSampler(cube, n_points = 32*32*32).make_static()\n", - "x_side_sampler = tp.samplers.RandomUniformSampler(Ix.boundary*Iy*Iz, n_points=100).make_static()\n", - "\n", - "y_side_sampler = tp.samplers.RandomUniformSampler(Iy.boundary*Ix*Iz, n_points=100).make_static()\n", - "\n", - "top_sampler = tp.samplers.RandomUniformSampler(Ix*Iy*Iz.boundary_right, n_points=200).make_static()\n", - "bottom_sampler = tp.samplers.RandomUniformSampler(Ix*Iy*Iz.boundary_left, n_points=100).make_static()\n", - "\n", - "\n", - "xy_square = tp.domains.Parallelogram(X*Y, [-size, -size], [size, -size], [-size, size])\n", - "samp = tp.samplers.PlotSampler(xy_square, n_points=1000, data_for_other_variables={'z': 0.0})\n", - "\n", - "optim = tp.solver.OptimizerSetting(torch.optim.LBFGS, lr=0.1) #' Adam, Adagrad '\n", - "solver = tp.solver.Solver([pde_condition, bc_x_condition, bc_y_condition, bc_z_top_cond, bc_z_bottom_cond],\n", - " optimizer_setting = optim)\n", - "\n", - "calls = [tp.utils.PlotterCallback(model=model,plot_function=plot_displacement_z,point_sampler=samp,\n", - " log_name='ausgabe', plot_type='contour_surface',check_interval=10), \n", - " tp.utils.WeightSaveCallback(model=model,path='.',name='NN',check_interval = 10, save_initial_model=False,\n", - " save_final_model = True)]\n", - "\n", - "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", - " num_sanity_val_steps=0,\n", - " benchmark=True,\n", - " max_steps=300, \n", - " logger=False, \n", - " enable_checkpointing=False)\n", - "trainer.fit(solver)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Verschiebung in z-Richtung [mm]')" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "xy_square = tp.domains.Parallelogram(X*Y, [-size, -size], [size, -size], [-size, size])\n", - "samp = tp.samplers.PlotSampler(xy_square, n_points=2000, data_for_other_variables={'z': 4.5})\n", - "fig = tp.utils.plot(model, plot_displacement_z, samp, plot_type='contour_surface')\n", - "pyplot.title('Verschiebung in z-Richtung [mm]')\n", - "#pyplot.savefig('Verschiebung-y-Richtung.png', dvi=720)" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Verschiebung in x-Richtung [mm]')" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "xy_square = tp.domains.Parallelogram(X*Y, [-size, -size], [size, -size], [-size, size])\n", - "samp = tp.samplers.PlotSampler(xy_square, n_points=2000, data_for_other_variables={'z': 5.0})\n", - "fig = tp.utils.plot(model, plot_displacement_x, samp, plot_type='contour_surface')\n", - "pyplot.title('Verschiebung in x-Richtung [mm]')\n", - "#pyplot.savefig('Verschiebung-x-Richtung.png', dvi=720)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":21: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"dvi\" which is no longer supported as of 3.3 and will become an error two minor releases later\n", - " pyplot.savefig('sigma-x-y-z=45.png', dvi=360)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "kappa = 18333.3\n", - "mu = 3928.57 \n", - "\n", - "C = torch.zeros((3, 3, 3, 3), dtype=torch.float32)\n", - "for i,j,k,l in itertools.product(range(3), range(3), range(3), range(3)):\n", - " unit_prod = delta(i, j) * delta(k, l)\n", - " P_sym = 0.5 * (delta(i, k) * delta(j, l) + delta(j, k) * delta(i, l)) - 1/3.0*unit_prod\n", - " C[i,j,k,l] = kappa * unit_prod + 2*mu*P_sym\n", - " \n", - "C = C.reshape(9, 1, 3, 3)\n", - "\n", - "def strain_fn(u, x, y, z):\n", - " sym_grad = tp.utils.sym_grad(u, x, y, z)\n", - " prod = C*sym_grad\n", - " sigma = (prod.sum(dim=(2, 3))).T.reshape(len(u), 3, 3)\n", - " return torch.norm(sigma, dim=(1,2))\n", - "\n", - "samp = tp.samplers.PlotSampler(xy_square, n_points=1000, data_for_other_variables={'z':4.0})\n", - "fig = tp.utils.plot(model, strain_fn, samp, plot_type='contour_surface')\n", - "pyplot.title('Spannung $\\sigma$ $[N/mm^2]$')\n", - "pyplot.savefig('sigma-x-y-z=45.png', dvi=360)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Spannung $N/mm^2$')" - ] - }, - "execution_count": 35, - "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" - } - ], - "source": [ - "x_interval = tp.domains.Interval(X, -size, size)\n", - "y_interval = tp.domains.Interval(Y, -size, size)\n", - "z_ebene = 2.0\n", - "samp1 = tp.samplers.PlotSampler(y_interval, n_points=100, data_for_other_variables={'x':0.0,'z': z_ebene})\n", - "samp2 = tp.samplers.PlotSampler(x_interval, n_points=100, data_for_other_variables={'y':0.0,'z': z_ebene})\n", - "fig1 = tp.utils.plot(model, strain_fn, samp1)\n", - "fig2 = tp.utils.plot(model, strain_fn, samp2)\n", - "pyplot.ylabel('Spannung $N/mm^2$')" - ] - } - ], - "metadata": { - "interpreter": { - "hash": "fb770cb910411e790a99fd848f827dc995ac53be5098d939fbaa56bcec3c9277" - }, - "kernelspec": { - "display_name": "Python [conda env:.conda-pytorch-physics]", - "language": "python", - "name": "conda-env-.conda-pytorch-physics-py" - }, - "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.6" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/solid_mechanics/sigma-x-y-z=45.png b/examples/solid_mechanics/sigma-x-y-z=45.png deleted file mode 100644 index 5f2819b8..00000000 Binary files a/examples/solid_mechanics/sigma-x-y-z=45.png and /dev/null differ diff --git a/examples/tutorial/Introduction_Tutorial_PINNs.ipynb b/examples/tutorial/Introduction_Tutorial_PINNs.ipynb index 08c99c3e..1dc7c0cc 100644 --- a/examples/tutorial/Introduction_Tutorial_PINNs.ipynb +++ b/examples/tutorial/Introduction_Tutorial_PINNs.ipynb @@ -1,1881 +1,1193 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "id": "1ef6d147-2dd4-4547-9fb6-79b3758d7350", - "metadata": { - "id": "1ef6d147-2dd4-4547-9fb6-79b3758d7350" - }, - "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": { - "id": "7cf51978-f0cb-4331-ba1c-9ee4ca6bf8f0" - }, - "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": 3, - "id": "d6b5fdd2-67c1-4f7e-a185-9d515fb9f3f8", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 430 - }, - "id": "d6b5fdd2-67c1-4f7e-a185-9d515fb9f3f8", - "outputId": "b6f2faea-b0e8-4af0-dc49-e8312374062b" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "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": { - "id": "8da6279e-83c2-41ed-a56b-453b21f05d11" - }, - "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": { - "id": "8f0db4a0-cace-4d21-845f-f34680880d7d" - }, - "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://boschresearch.github.io/torchphysics/tutorial/tutorial_start.html) or [examples](https://boschresearch.github.io/torchphysics/examples.html)." - ] - }, - { - "cell_type": "markdown", - "id": "e8fe0433-82b7-4093-8f6f-8adf7e46ff5b", - "metadata": { - "id": "e8fe0433-82b7-4093-8f6f-8adf7e46ff5b" - }, - "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://boschresearch.github.io/torchphysics/tutorial/tutorial_domain_basics.html)." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "6af0dba0-d481-4566-a8b7-244098eee713", - "metadata": { - "id": "6af0dba0-d481-4566-a8b7-244098eee713" - }, - "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": 5, - "id": "1efe92cb-daab-4d21-8a43-5008e3e9248a", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 449 - }, - "id": "1efe92cb-daab-4d21-8a43-5008e3e9248a", - "outputId": "cdb09abd-279c-42b4-b96c-7f244d36d305" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "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=500)\n", - "plot = tp.utils.scatter(X, Omega_sampler)" - ] - }, - { - "cell_type": "markdown", - "id": "a1676bc3-8dab-4ce4-84ff-f8fc29e8b829", - "metadata": { - "id": "a1676bc3-8dab-4ce4-84ff-f8fc29e8b829" - }, - "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://boschresearch.github.io/torchphysics/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": 6, - "id": "d428cf7f-89ee-4f3f-a1bf-822b82550a7e", - "metadata": { - "id": "d428cf7f-89ee-4f3f-a1bf-822b82550a7e" - }, - "outputs": [], - "source": [ - "domain_pde_condition = Omega * I" - ] - }, - { - "cell_type": "markdown", - "id": "8db04580-edb8-45ac-8f48-091450647377", - "metadata": { - "id": "8db04580-edb8-45ac-8f48-091450647377" - }, - "source": [ - "Having the relevant domain on hand, we initialize as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "d020f7f4-c286-466f-928d-1f80ee64c53f", - "metadata": { - "id": "d020f7f4-c286-466f-928d-1f80ee64c53f" - }, - "outputs": [], - "source": [ - "sampler_pde_condition = tp.samplers.RandomUniformSampler(domain=domain_pde_condition, n_points=1500)" - ] - }, - { - "cell_type": "markdown", - "id": "ac69b667-1a77-4e8a-8a20-2e0b5a1de2a0", - "metadata": { - "id": "ac69b667-1a77-4e8a-8a20-2e0b5a1de2a0" - }, - "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": 8, - "id": "3a1ee851-1bd4-4ee2-83e4-7dca3f883c0f", - "metadata": { - "id": "3a1ee851-1bd4-4ee2-83e4-7dca3f883c0f" - }, - "outputs": [], - "source": [ - "sampler_Omega = tp.samplers.GridSampler(domain=Omega, n_points=1000)\n", - "sampler_I = tp.samplers.RandomUniformSampler(domain=I, n_points=500)\n", - "alternative_sampler_pde_condition = sampler_Omega * sampler_I" - ] - }, - { - "cell_type": "markdown", - "id": "c9f72b70-0e87-466f-a7c0-0e1f194745cc", - "metadata": { - "id": "c9f72b70-0e87-466f-a7c0-0e1f194745cc" - }, - "source": [ - "For more detailed information on the functionality of TorchPysics samplers, please have a look at the [examples](https://boschresearch.github.io/torchphysics/examples.html) or [sampler-tutorial](https://boschresearch.github.io/torchphysics/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": 9, - "id": "e780f5fa-5ebf-4731-8568-77116ea039f6", - "metadata": { - "id": "e780f5fa-5ebf-4731-8568-77116ea039f6" - }, - "outputs": [], - "source": [ - "domain_initial_condition = Omega * I.boundary_left\n", - "sampler_initial_condition = tp.samplers.RandomUniformSampler(domain_initial_condition, 2500)" - ] - }, - { - "cell_type": "markdown", - "id": "7750bf6b-30ec-4ca9-8f37-9699439d0d22", - "metadata": { - "id": "7750bf6b-30ec-4ca9-8f37-9699439d0d22" - }, - "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": 10, - "id": "b627951a-a12b-4333-b965-35a56b8fc396", - "metadata": { - "id": "b627951a-a12b-4333-b965-35a56b8fc396" - }, - "outputs": [], - "source": [ - "domain_boundary_condition = Omega.boundary * I\n", - "sampler_boundary_condition = tp.samplers.RandomUniformSampler(domain_boundary_condition, 2500)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "c23a19e6-4167-4785-8323-984c319e2cb4", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 449 - }, - "id": "c23a19e6-4167-4785-8323-984c319e2cb4", - "outputId": "f47cb4e2-7c58-41e3-8d5b-445b02ec45fa" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Visualization of sampled points at the boundary\n", - "plot = tp.utils.scatter(X, sampler_boundary_condition)" - ] - }, - { - "cell_type": "markdown", - "id": "6b1b87f9-b6d6-44ec-8fb5-833ab466d89b", - "metadata": { - "id": "6b1b87f9-b6d6-44ec-8fb5-833ab466d89b" - }, - "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://boschresearch.github.io/torchphysics/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": 12, - "id": "c29f3f92-d613-470f-ab74-9369e071ea04", - "metadata": { - "id": "c29f3f92-d613-470f-ab74-9369e071ea04" - }, - "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": { - "id": "e444a2e5-6fc6-4124-894c-1ba987153241" - }, - "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": 13, - "id": "65954de9-4c80-4d2a-be6e-0cd16ab82596", - "metadata": { - "id": "65954de9-4c80-4d2a-be6e-0cd16ab82596" - }, - "outputs": [], - "source": [ - "def residual_initial_condition(u):\n", - " return u - u_0" - ] - }, - { - "cell_type": "markdown", - "id": "97b9bfba-5cd3-400c-8c5a-4cd48b320c80", - "metadata": { - "id": "97b9bfba-5cd3-400c-8c5a-4cd48b320c80" - }, - "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": 14, - "id": "c97e8bfe-1580-4bb8-bb1b-d4c874ef6244", - "metadata": { - "id": "c97e8bfe-1580-4bb8-bb1b-d4c874ef6244" - }, - "outputs": [], - "source": [ - "def residual_dirichlet_condition(u, t):\n", - " return u - h(t)" - ] - }, - { - "cell_type": "markdown", - "id": "de441693-0870-43db-8d8d-38777a075432", - "metadata": { - "id": "de441693-0870-43db-8d8d-38777a075432" - }, - "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": 15, - "id": "17d5e293-57bd-4739-9518-a014f6df2b79", - "metadata": { - "id": "17d5e293-57bd-4739-9518-a014f6df2b79" - }, - "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": { - "id": "463e507e-d33b-4f8d-9149-c45356fdf236" - }, - "source": [ - "The combined boundary residual $R_b$ is then easily obtained as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "4864c6ed-6f2b-4f80-bd6f-cd8ff3d8a809", - "metadata": { - "id": "4864c6ed-6f2b-4f80-bd6f-cd8ff3d8a809" - }, - "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": { - "id": "0cc89ada-310b-4a84-bcc0-77baa7afca2c" - }, - "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://boschresearch.github.io/torchphysics/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": 17, - "id": "bdef3d80-90e6-47aa-95ce-6d735fd03f36", - "metadata": { - "id": "bdef3d80-90e6-47aa-95ce-6d735fd03f36" - }, - "outputs": [], - "source": [ - "normalization_layer = tp.models.NormalizationLayer(Omega*I)" - ] - }, - { - "cell_type": "markdown", - "id": "75e0d506-13f0-4e39-882b-d752c89fe7fc", - "metadata": { - "id": "75e0d506-13f0-4e39-882b-d752c89fe7fc" - }, - "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": 18, - "id": "fa15606a-a2c7-40bf-9e41-920c8f6a1bc9", - "metadata": { - "id": "fa15606a-a2c7-40bf-9e41-920c8f6a1bc9" - }, - "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": { - "id": "694d8666-170e-4c28-a87a-73aa329e2094" - }, - "source": [ - "Similar to Pytorch, the normalization layer and FCN can be concatenated by the class \"tp.models.Sequential\":" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "9b838d6f-1b90-4667-8ecb-9f54b4ec627e", - "metadata": { - "id": "9b838d6f-1b90-4667-8ecb-9f54b4ec627e" - }, - "outputs": [], - "source": [ - "model = tp.models.Sequential(normalization_layer, fcn_layer)" - ] - }, - { - "cell_type": "markdown", - "id": "17e3f8ab-bd6c-4f4f-94a6-030930458c0c", - "metadata": { - "id": "17e3f8ab-bd6c-4f4f-94a6-030930458c0c" - }, - "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://boschresearch.github.io/torchphysics/tutorial/condition_tutorial.html) for further information." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "008c09a7-81f8-41b5-8c10-3892812740ad", - "metadata": { - "id": "008c09a7-81f8-41b5-8c10-3892812740ad" - }, - "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": { - "id": "5cd77316-3c78-4bf1-b639-9ccb7070af2d" - }, - "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": { - "id": "2e0fad4c-2cfd-4c10-8e2f-0a3702a2eeac" - }, - "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/boschresearch/torchphysics/blob/main/examples/pinn/interface-jump.ipynb) to train different networks for different conditions of the PDE problem." - ] - }, - { - "cell_type": "markdown", - "id": "31d80c43-5879-401c-8212-0e4a5fd6514c", - "metadata": { - "id": "31d80c43-5879-401c-8212-0e4a5fd6514c" - }, - "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": 21, - "id": "bb76e892-bf53-4a01-adc5-74dddb770525", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "bb76e892-bf53-4a01-adc5-74dddb770525", - "outputId": "90104470-f0c5-40ab-e922-3c9915202fd6" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "GPU available: False\n" - ] - } - ], - "source": [ - "import pytorch_lightning as pl\n", - "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\" if torch.cuda.is_available() else \"0\"\n", - "\n", - "print (\"GPU available: \" + str(torch.cuda.is_available()))" - ] - }, - { - "cell_type": "markdown", - "id": "1639cf38-835b-4571-b0c5-7ef0d130c2df", - "metadata": { - "id": "1639cf38-835b-4571-b0c5-7ef0d130c2df" - }, - "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": 22, - "id": "ea27b608-e319-4fac-85c1-5984f2d043c6", - "metadata": { - "id": "ea27b608-e319-4fac-85c1-5984f2d043c6" - }, - "outputs": [], - "source": [ - "training_conditions = [pde_condition, initial_condition, boundary_condition]" - ] - }, - { - "cell_type": "markdown", - "id": "e024913e-e10e-4387-b390-165e77c8524b", - "metadata": { - "id": "e024913e-e10e-4387-b390-165e77c8524b" - }, - "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": 23, - "id": "b1848d26-ea33-400c-84be-2291429e8065", - "metadata": { - "id": "b1848d26-ea33-400c-84be-2291429e8065" - }, - "outputs": [], - "source": [ - "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.0005)" - ] - }, - { - "cell_type": "markdown", - "id": "efcd0c8c-1ef2-45a0-bf00-de88201f3d03", - "metadata": { - "id": "efcd0c8c-1ef2-45a0-bf00-de88201f3d03" - }, - "source": [ - "Finally, we are able to create the Solver object, a Pytorch Lightning Module." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "4ea2cb3f-087c-4e03-aeb0-40318f556062", - "metadata": { - "id": "4ea2cb3f-087c-4e03-aeb0-40318f556062" - }, - "outputs": [], - "source": [ - "solver = tp.solver.Solver(train_conditions=training_conditions, optimizer_setting=optim)" - ] - }, - { - "cell_type": "markdown", - "id": "53dec402-5dd2-40f9-a405-5170d0cfcbd7", - "metadata": { - "id": "53dec402-5dd2-40f9-a405-5170d0cfcbd7" - }, - "source": [ - "Now, as usual, the training is done with a Pytorch Lightning Trainer object and its fit() method." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "9ea9431a-9ea4-4312-8869-af4c8c4733a4", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 327, - "referenced_widgets": [ - "c0c85ee450fa4382b8ba6d076bbe15ab", - "b51fd3c0f34740719b885c8931acb307", - "b0f8c43fb244435fa250e90aa431a910", - "b78a8f1dc2f34425b15c9f4b785e59c7", - "c45982b9a83b47779e614305dbbfc2ac", - "cafdac53e72d48bba71a7c98538c5354", - "51d400ec3dab4d3db89d4ae1212e0cce", - "2a351ae394444086b648b09ffa58c06d", - "f8c630032aea45f6b3f97e838d7b74de", - "d66ce69c61594d8c972a49763e91d599", - "acd31f72a0184f859d18ad08567a61aa", - "8c926f8700a64539818ed8fe7b54bdea", - "30a318be130447cea4842d46d887360f", - "367e26e3fcff4add996e6b9c39cce77c", - "4a071277015d42e2876abd2fcec77f60", - "d7106f73c09d4ffc94f9146307913a93", - "436ad1ff35d841408e32383cd6ce6cb7", - "9e32d83238be4720909a1606779ce4a1", - "600a325e05fd4ead94806e30de2dfe91", - "d8765650eeba4c84be216cf3ffd27b0d", - "b026dd8e870a4557bc5583b5a509f59e", - "5a685209ec8e4496831015718305bacb" - ] - }, - "id": "9ea9431a-9ea4-4312-8869-af4c8c4733a4", - "outputId": "6e93ce9c-379c-4f4f-b946-16cf8b9652a5" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pytorch_lightning.utilities.rank_zero:GPU available: False, used: False\n", - "INFO:pytorch_lightning.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n", - "INFO:pytorch_lightning.utilities.rank_zero:HPU available: False, using: 0 HPUs\n", - "INFO:pytorch_lightning.callbacks.model_summary:\n", - " | Name | Type | Params | Mode \n", - "--------------------------------------------------------\n", - "0 | train_conditions | ModuleList | 9.5 K | train\n", - "1 | val_conditions | ModuleList | 0 | train\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", - "20 Modules in train mode\n", - "0 Modules in eval mode\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c0c85ee450fa4382b8ba6d076bbe15ab", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: | | 0/? [00:00" - ] - }, - "metadata": {}, - "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": { - "id": "54c7788a-d7a0-438c-821e-bef10f3f780f" - }, - "source": [ - "Let us visualize the solution of the PDE at further time points." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "e9e54d6e-f7a2-4746-a05e-681e3dbee8b7", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 449 - }, - "id": "e9e54d6e-f7a2-4746-a05e-681e3dbee8b7", - "outputId": "bc9feda3-d8bc-4e0a-8e50-7be9a6d8487d" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "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": 29, - "id": "10a7c785-90da-4b62-964f-af7d816ed1bd", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 449 - }, - "id": "10a7c785-90da-4b62-964f-af7d816ed1bd", - "outputId": "249db53f-3a95-4bca-aeff-019f9a9d4dce" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "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": 30, - "id": "c3e6a8cf-6bd5-42d6-a3ac-16c4a64eb22b", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 449 - }, - "id": "c3e6a8cf-6bd5-42d6-a3ac-16c4a64eb22b", - "outputId": "ca72f816-5fba-4edb-8f3c-62a8b624cae6" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "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": "c0cbc22a", - "metadata": { - "id": "c0cbc22a" - }, - "source": [ - "## Manual Visualization" - ] - }, - { - "cell_type": "markdown", - "id": "9d58e206-c27f-4ee6-8f4d-ddb1415c7221", - "metadata": { - "id": "9d58e206-c27f-4ee6-8f4d-ddb1415c7221" - }, - "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": 31, - "id": "9ccbb9b3-6f6a-4a29-8dc7-c2360b2df7c9", - "metadata": { - "id": "9ccbb9b3-6f6a-4a29-8dc7-c2360b2df7c9" - }, - "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", - "\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": { - "id": "26d9c9ba-77fe-4c21-af35-12e1376b113e" - }, - "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 have 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 the [space- and point-tutorial](https://boschresearch.github.io/torchphysics/tutorial/tutorial_spaces_and_points.html)." - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "67c99cdd-70db-4465-9ec0-8278b7381fa6", - "metadata": { - "id": "67c99cdd-70db-4465-9ec0-8278b7381fa6" - }, - "outputs": [], - "source": [ - "points = tp.spaces.Points(tensors, space=X*T)" - ] - }, - { - "cell_type": "markdown", - "id": "ce94a359-75dd-41e7-85b3-2000b2065054", - "metadata": { - "id": "ce94a359-75dd-41e7-85b3-2000b2065054" - }, - "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": 33, - "id": "854b969a-96f2-4088-b045-d1ca5cf0db64", - "metadata": { - "id": "854b969a-96f2-4088-b045-d1ca5cf0db64" - }, - "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": 34, - "id": "70d30023-ca42-460a-9906-2bcc736016ce", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 433 - }, - "id": "70d30023-ca42-460a-9906-2bcc736016ce", - "outputId": "a7a3ce2b-18e1-4fce-e1c5-e370e258cc85" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(np.rot90(output[:, :]), 'gray', vmin=vmin, vmax=vmax)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "9840aad9", - "metadata": { - "id": "9840aad9" - }, - "outputs": [], - "source": [] + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "1ef6d147-2dd4-4547-9fb6-79b3758d7350", + "metadata": { + "id": "1ef6d147-2dd4-4547-9fb6-79b3758d7350" + }, + "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": { + "id": "7cf51978-f0cb-4331-ba1c-9ee4ca6bf8f0" + }, + "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": 3, + "id": "d6b5fdd2-67c1-4f7e-a185-9d515fb9f3f8", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "d6b5fdd2-67c1-4f7e-a185-9d515fb9f3f8", + "outputId": "b6f2faea-b0e8-4af0-dc49-e8312374062b" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } - ], - "metadata": { + ], + "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": { + "id": "8da6279e-83c2-41ed-a56b-453b21f05d11" + }, + "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": { + "id": "8f0db4a0-cace-4d21-845f-f34680880d7d" + }, + "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://boschresearch.github.io/torchphysics/tutorial/tutorial_start.html) or [examples](https://boschresearch.github.io/torchphysics/examples.html)." + ] + }, + { + "cell_type": "markdown", + "id": "e8fe0433-82b7-4093-8f6f-8adf7e46ff5b", + "metadata": { + "id": "e8fe0433-82b7-4093-8f6f-8adf7e46ff5b" + }, + "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://boschresearch.github.io/torchphysics/tutorial/tutorial_domain_basics.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6af0dba0-d481-4566-a8b7-244098eee713", + "metadata": { + "id": "6af0dba0-d481-4566-a8b7-244098eee713" + }, + "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": 5, + "id": "1efe92cb-daab-4d21-8a43-5008e3e9248a", + "metadata": { "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.19" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "2a351ae394444086b648b09ffa58c06d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "30a318be130447cea4842d46d887360f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_436ad1ff35d841408e32383cd6ce6cb7", - "placeholder": "​", - "style": "IPY_MODEL_9e32d83238be4720909a1606779ce4a1", - "value": "Validation DataLoader 0: 100%" - } - }, - "367e26e3fcff4add996e6b9c39cce77c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_600a325e05fd4ead94806e30de2dfe91", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_d8765650eeba4c84be216cf3ffd27b0d", - "value": 1 - } - }, - "436ad1ff35d841408e32383cd6ce6cb7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4a071277015d42e2876abd2fcec77f60": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_b026dd8e870a4557bc5583b5a509f59e", - "placeholder": "​", - "style": "IPY_MODEL_5a685209ec8e4496831015718305bacb", - "value": " 1/1 [00:00<00:00, 318.04it/s]" - } - }, - "51d400ec3dab4d3db89d4ae1212e0cce": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "5a685209ec8e4496831015718305bacb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "600a325e05fd4ead94806e30de2dfe91": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "8c926f8700a64539818ed8fe7b54bdea": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_30a318be130447cea4842d46d887360f", - "IPY_MODEL_367e26e3fcff4add996e6b9c39cce77c", - "IPY_MODEL_4a071277015d42e2876abd2fcec77f60" - ], - "layout": "IPY_MODEL_d7106f73c09d4ffc94f9146307913a93" - } - }, - "9e32d83238be4720909a1606779ce4a1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "acd31f72a0184f859d18ad08567a61aa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "b026dd8e870a4557bc5583b5a509f59e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b0f8c43fb244435fa250e90aa431a910": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2a351ae394444086b648b09ffa58c06d", - "max": 5000, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_f8c630032aea45f6b3f97e838d7b74de", - "value": 5000 - } - }, - "b51fd3c0f34740719b885c8931acb307": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_cafdac53e72d48bba71a7c98538c5354", - "placeholder": "​", - "style": "IPY_MODEL_51d400ec3dab4d3db89d4ae1212e0cce", - "value": "Epoch 0: 100%" - } - }, - "b78a8f1dc2f34425b15c9f4b785e59c7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_d66ce69c61594d8c972a49763e91d599", - "placeholder": "​", - "style": "IPY_MODEL_acd31f72a0184f859d18ad08567a61aa", - "value": " 5000/5000 [08:16<00:00, 10.06it/s, train/loss=0.837]" - } - }, - "c0c85ee450fa4382b8ba6d076bbe15ab": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b51fd3c0f34740719b885c8931acb307", - "IPY_MODEL_b0f8c43fb244435fa250e90aa431a910", - "IPY_MODEL_b78a8f1dc2f34425b15c9f4b785e59c7" - ], - "layout": "IPY_MODEL_c45982b9a83b47779e614305dbbfc2ac" - } - }, - "c45982b9a83b47779e614305dbbfc2ac": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "100%" - } - }, - "cafdac53e72d48bba71a7c98538c5354": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d66ce69c61594d8c972a49763e91d599": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d7106f73c09d4ffc94f9146307913a93": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "d8765650eeba4c84be216cf3ffd27b0d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "f8c630032aea45f6b3f97e838d7b74de": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - } - } + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "1efe92cb-daab-4d21-8a43-5008e3e9248a", + "outputId": "cdb09abd-279c-42b4-b96c-7f244d36d305" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "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=500)\n", + "plot = tp.utils.scatter(X, Omega_sampler)" + ] + }, + { + "cell_type": "markdown", + "id": "a1676bc3-8dab-4ce4-84ff-f8fc29e8b829", + "metadata": { + "id": "a1676bc3-8dab-4ce4-84ff-f8fc29e8b829" + }, + "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://boschresearch.github.io/torchphysics/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": 6, + "id": "d428cf7f-89ee-4f3f-a1bf-822b82550a7e", + "metadata": { + "id": "d428cf7f-89ee-4f3f-a1bf-822b82550a7e" + }, + "outputs": [], + "source": [ + "domain_pde_condition = Omega * I" + ] + }, + { + "cell_type": "markdown", + "id": "8db04580-edb8-45ac-8f48-091450647377", + "metadata": { + "id": "8db04580-edb8-45ac-8f48-091450647377" + }, + "source": [ + "Having the relevant domain on hand, we initialize as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d020f7f4-c286-466f-928d-1f80ee64c53f", + "metadata": { + "id": "d020f7f4-c286-466f-928d-1f80ee64c53f" + }, + "outputs": [], + "source": [ + "sampler_pde_condition = tp.samplers.RandomUniformSampler(domain=domain_pde_condition, n_points=1500)" + ] + }, + { + "cell_type": "markdown", + "id": "ac69b667-1a77-4e8a-8a20-2e0b5a1de2a0", + "metadata": { + "id": "ac69b667-1a77-4e8a-8a20-2e0b5a1de2a0" + }, + "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": 8, + "id": "3a1ee851-1bd4-4ee2-83e4-7dca3f883c0f", + "metadata": { + "id": "3a1ee851-1bd4-4ee2-83e4-7dca3f883c0f" + }, + "outputs": [], + "source": [ + "sampler_Omega = tp.samplers.GridSampler(domain=Omega, n_points=1000)\n", + "sampler_I = tp.samplers.RandomUniformSampler(domain=I, n_points=500)\n", + "alternative_sampler_pde_condition = sampler_Omega * sampler_I" + ] + }, + { + "cell_type": "markdown", + "id": "c9f72b70-0e87-466f-a7c0-0e1f194745cc", + "metadata": { + "id": "c9f72b70-0e87-466f-a7c0-0e1f194745cc" + }, + "source": [ + "For more detailed information on the functionality of TorchPysics samplers, please have a look at the [examples](https://boschresearch.github.io/torchphysics/examples.html) or [sampler-tutorial](https://boschresearch.github.io/torchphysics/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 \"boundary_left\", an instance of TorchPhysics BoundaryDomain class, a subclass of the Domain class." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e780f5fa-5ebf-4731-8568-77116ea039f6", + "metadata": { + "id": "e780f5fa-5ebf-4731-8568-77116ea039f6" + }, + "outputs": [], + "source": [ + "domain_initial_condition = Omega * I.boundary_left\n", + "sampler_initial_condition = tp.samplers.RandomUniformSampler(domain_initial_condition, 2500)" + ] + }, + { + "cell_type": "markdown", + "id": "7750bf6b-30ec-4ca9-8f37-9699439d0d22", + "metadata": { + "id": "7750bf6b-30ec-4ca9-8f37-9699439d0d22" + }, + "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": 10, + "id": "b627951a-a12b-4333-b965-35a56b8fc396", + "metadata": { + "id": "b627951a-a12b-4333-b965-35a56b8fc396" + }, + "outputs": [], + "source": [ + "domain_boundary_condition = Omega.boundary * I\n", + "sampler_boundary_condition = tp.samplers.RandomUniformSampler(domain_boundary_condition, 2500)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c23a19e6-4167-4785-8323-984c319e2cb4", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "c23a19e6-4167-4785-8323-984c319e2cb4", + "outputId": "f47cb4e2-7c58-41e3-8d5b-445b02ec45fa" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualization of sampled points at the boundary\n", + "plot = tp.utils.scatter(X, sampler_boundary_condition)" + ] + }, + { + "cell_type": "markdown", + "id": "6b1b87f9-b6d6-44ec-8fb5-833ab466d89b", + "metadata": { + "id": "6b1b87f9-b6d6-44ec-8fb5-833ab466d89b" + }, + "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://boschresearch.github.io/torchphysics/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": 12, + "id": "c29f3f92-d613-470f-ab74-9369e071ea04", + "metadata": { + "id": "c29f3f92-d613-470f-ab74-9369e071ea04" + }, + "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": { + "id": "e444a2e5-6fc6-4124-894c-1ba987153241" + }, + "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": 13, + "id": "65954de9-4c80-4d2a-be6e-0cd16ab82596", + "metadata": { + "id": "65954de9-4c80-4d2a-be6e-0cd16ab82596" + }, + "outputs": [], + "source": [ + "def residual_initial_condition(u):\n", + " return u - u_0" + ] + }, + { + "cell_type": "markdown", + "id": "97b9bfba-5cd3-400c-8c5a-4cd48b320c80", + "metadata": { + "id": "97b9bfba-5cd3-400c-8c5a-4cd48b320c80" + }, + "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": 14, + "id": "c97e8bfe-1580-4bb8-bb1b-d4c874ef6244", + "metadata": { + "id": "c97e8bfe-1580-4bb8-bb1b-d4c874ef6244" + }, + "outputs": [], + "source": [ + "def residual_dirichlet_condition(u, t):\n", + " return u - h(t)" + ] + }, + { + "cell_type": "markdown", + "id": "de441693-0870-43db-8d8d-38777a075432", + "metadata": { + "id": "de441693-0870-43db-8d8d-38777a075432" + }, + "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": 15, + "id": "17d5e293-57bd-4739-9518-a014f6df2b79", + "metadata": { + "id": "17d5e293-57bd-4739-9518-a014f6df2b79" + }, + "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": { + "id": "463e507e-d33b-4f8d-9149-c45356fdf236" + }, + "source": [ + "The combined boundary residual $R_b$ is then easily obtained as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "4864c6ed-6f2b-4f80-bd6f-cd8ff3d8a809", + "metadata": { + "id": "4864c6ed-6f2b-4f80-bd6f-cd8ff3d8a809" + }, + "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": { + "id": "0cc89ada-310b-4a84-bcc0-77baa7afca2c" + }, + "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://boschresearch.github.io/torchphysics/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": 17, + "id": "bdef3d80-90e6-47aa-95ce-6d735fd03f36", + "metadata": { + "id": "bdef3d80-90e6-47aa-95ce-6d735fd03f36" + }, + "outputs": [], + "source": [ + "normalization_layer = tp.models.NormalizationLayer(Omega*I)" + ] + }, + { + "cell_type": "markdown", + "id": "75e0d506-13f0-4e39-882b-d752c89fe7fc", + "metadata": { + "id": "75e0d506-13f0-4e39-882b-d752c89fe7fc" + }, + "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": 18, + "id": "fa15606a-a2c7-40bf-9e41-920c8f6a1bc9", + "metadata": { + "id": "fa15606a-a2c7-40bf-9e41-920c8f6a1bc9" + }, + "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": { + "id": "694d8666-170e-4c28-a87a-73aa329e2094" + }, + "source": [ + "Similar to Pytorch, the normalization layer and FCN can be concatenated by the class \"tp.models.Sequential\":" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "9b838d6f-1b90-4667-8ecb-9f54b4ec627e", + "metadata": { + "id": "9b838d6f-1b90-4667-8ecb-9f54b4ec627e" + }, + "outputs": [], + "source": [ + "model = tp.models.Sequential(normalization_layer, fcn_layer)" + ] + }, + { + "cell_type": "markdown", + "id": "17e3f8ab-bd6c-4f4f-94a6-030930458c0c", + "metadata": { + "id": "17e3f8ab-bd6c-4f4f-94a6-030930458c0c" + }, + "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://boschresearch.github.io/torchphysics/tutorial/condition_tutorial.html) for further information." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "008c09a7-81f8-41b5-8c10-3892812740ad", + "metadata": { + "id": "008c09a7-81f8-41b5-8c10-3892812740ad" + }, + "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": { + "id": "5cd77316-3c78-4bf1-b639-9ccb7070af2d" + }, + "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": { + "id": "2e0fad4c-2cfd-4c10-8e2f-0a3702a2eeac" + }, + "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/boschresearch/torchphysics/blob/main/examples/pinn/interface-jump.ipynb) to train different networks for different conditions of the PDE problem." + ] + }, + { + "cell_type": "markdown", + "id": "31d80c43-5879-401c-8212-0e4a5fd6514c", + "metadata": { + "id": "31d80c43-5879-401c-8212-0e4a5fd6514c" + }, + "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": 21, + "id": "bb76e892-bf53-4a01-adc5-74dddb770525", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bb76e892-bf53-4a01-adc5-74dddb770525", + "outputId": "90104470-f0c5-40ab-e922-3c9915202fd6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GPU available: False\n" + ] + } + ], + "source": [ + "import pytorch_lightning as pl\n", + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\" if torch.cuda.is_available() else \"0\"\n", + "\n", + "print (\"GPU available: \" + str(torch.cuda.is_available()))" + ] + }, + { + "cell_type": "markdown", + "id": "1639cf38-835b-4571-b0c5-7ef0d130c2df", + "metadata": { + "id": "1639cf38-835b-4571-b0c5-7ef0d130c2df" + }, + "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": 22, + "id": "ea27b608-e319-4fac-85c1-5984f2d043c6", + "metadata": { + "id": "ea27b608-e319-4fac-85c1-5984f2d043c6" + }, + "outputs": [], + "source": [ + "training_conditions = [pde_condition, initial_condition, boundary_condition]" + ] + }, + { + "cell_type": "markdown", + "id": "e024913e-e10e-4387-b390-165e77c8524b", + "metadata": { + "id": "e024913e-e10e-4387-b390-165e77c8524b" + }, + "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": 23, + "id": "b1848d26-ea33-400c-84be-2291429e8065", + "metadata": { + "id": "b1848d26-ea33-400c-84be-2291429e8065" + }, + "outputs": [], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.0005)" + ] + }, + { + "cell_type": "markdown", + "id": "efcd0c8c-1ef2-45a0-bf00-de88201f3d03", + "metadata": { + "id": "efcd0c8c-1ef2-45a0-bf00-de88201f3d03" + }, + "source": [ + "Finally, we are able to create the Solver object, a Pytorch Lightning Module." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "4ea2cb3f-087c-4e03-aeb0-40318f556062", + "metadata": { + "id": "4ea2cb3f-087c-4e03-aeb0-40318f556062" + }, + "outputs": [], + "source": [ + "solver = tp.solver.Solver(train_conditions=training_conditions, optimizer_setting=optim)" + ] + }, + { + "cell_type": "markdown", + "id": "53dec402-5dd2-40f9-a405-5170d0cfcbd7", + "metadata": { + "id": "53dec402-5dd2-40f9-a405-5170d0cfcbd7" + }, + "source": [ + "Now, as usual, the training is done with a Pytorch Lightning Trainer object and its fit() method." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "9ea9431a-9ea4-4312-8869-af4c8c4733a4", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 327, + "referenced_widgets": [ + "c0c85ee450fa4382b8ba6d076bbe15ab", + "b51fd3c0f34740719b885c8931acb307", + "b0f8c43fb244435fa250e90aa431a910", + "b78a8f1dc2f34425b15c9f4b785e59c7", + "c45982b9a83b47779e614305dbbfc2ac", + "cafdac53e72d48bba71a7c98538c5354", + "51d400ec3dab4d3db89d4ae1212e0cce", + "2a351ae394444086b648b09ffa58c06d", + "f8c630032aea45f6b3f97e838d7b74de", + "d66ce69c61594d8c972a49763e91d599", + "acd31f72a0184f859d18ad08567a61aa", + "8c926f8700a64539818ed8fe7b54bdea", + "30a318be130447cea4842d46d887360f", + "367e26e3fcff4add996e6b9c39cce77c", + "4a071277015d42e2876abd2fcec77f60", + "d7106f73c09d4ffc94f9146307913a93", + "436ad1ff35d841408e32383cd6ce6cb7", + "9e32d83238be4720909a1606779ce4a1", + "600a325e05fd4ead94806e30de2dfe91", + "d8765650eeba4c84be216cf3ffd27b0d", + "b026dd8e870a4557bc5583b5a509f59e", + "5a685209ec8e4496831015718305bacb" + ] + }, + "id": "9ea9431a-9ea4-4312-8869-af4c8c4733a4", + "outputId": "6e93ce9c-379c-4f4f-b946-16cf8b9652a5" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:pytorch_lightning.utilities.rank_zero:GPU available: False, used: False\n", + "INFO:pytorch_lightning.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n", + "INFO:pytorch_lightning.utilities.rank_zero:HPU available: False, using: 0 HPUs\n", + "INFO:pytorch_lightning.callbacks.model_summary:\n", + " | Name | Type | Params | Mode \n", + "--------------------------------------------------------\n", + "0 | train_conditions | ModuleList | 9.5 K | train\n", + "1 | val_conditions | ModuleList | 0 | train\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", + "20 Modules in train mode\n", + "0 Modules in eval mode\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c0c85ee450fa4382b8ba6d076bbe15ab", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00" + ] + }, + "metadata": {}, + "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": { + "id": "54c7788a-d7a0-438c-821e-bef10f3f780f" + }, + "source": [ + "Let us visualize the solution of the PDE at further time points." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "e9e54d6e-f7a2-4746-a05e-681e3dbee8b7", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "e9e54d6e-f7a2-4746-a05e-681e3dbee8b7", + "outputId": "bc9feda3-d8bc-4e0a-8e50-7be9a6d8487d" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "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": 29, + "id": "10a7c785-90da-4b62-964f-af7d816ed1bd", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "10a7c785-90da-4b62-964f-af7d816ed1bd", + "outputId": "249db53f-3a95-4bca-aeff-019f9a9d4dce" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "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": 30, + "id": "c3e6a8cf-6bd5-42d6-a3ac-16c4a64eb22b", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "c3e6a8cf-6bd5-42d6-a3ac-16c4a64eb22b", + "outputId": "ca72f816-5fba-4edb-8f3c-62a8b624cae6" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "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": "c0cbc22a", + "metadata": { + "id": "c0cbc22a" + }, + "source": [ + "## Manual Visualization" + ] + }, + { + "cell_type": "markdown", + "id": "9d58e206-c27f-4ee6-8f4d-ddb1415c7221", + "metadata": { + "id": "9d58e206-c27f-4ee6-8f4d-ddb1415c7221" + }, + "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": 31, + "id": "9ccbb9b3-6f6a-4a29-8dc7-c2360b2df7c9", + "metadata": { + "id": "9ccbb9b3-6f6a-4a29-8dc7-c2360b2df7c9" + }, + "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", + "\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": { + "id": "26d9c9ba-77fe-4c21-af35-12e1376b113e" + }, + "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 have 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 the [space- and point-tutorial](https://boschresearch.github.io/torchphysics/tutorial/tutorial_spaces_and_points.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "67c99cdd-70db-4465-9ec0-8278b7381fa6", + "metadata": { + "id": "67c99cdd-70db-4465-9ec0-8278b7381fa6" + }, + "outputs": [], + "source": [ + "points = tp.spaces.Points(tensors, space=X*T)" + ] + }, + { + "cell_type": "markdown", + "id": "ce94a359-75dd-41e7-85b3-2000b2065054", + "metadata": { + "id": "ce94a359-75dd-41e7-85b3-2000b2065054" + }, + "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": 33, + "id": "854b969a-96f2-4088-b045-d1ca5cf0db64", + "metadata": { + "id": "854b969a-96f2-4088-b045-d1ca5cf0db64" + }, + "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": 34, + "id": "70d30023-ca42-460a-9906-2bcc736016ce", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "id": "70d30023-ca42-460a-9906-2bcc736016ce", + "outputId": "a7a3ce2b-18e1-4fce-e1c5-e370e258cc85" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(np.rot90(output[:, :]), 'gray', vmin=vmin, vmax=vmax)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "9840aad9", + "metadata": { + "id": "9840aad9" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 5 + "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.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 } diff --git a/examples/tutorial/Tutorial_PIDeepONet.ipynb b/examples/tutorial/Tutorial_PIDeepONet.ipynb index cf39faeb..8ca2b736 100644 --- a/examples/tutorial/Tutorial_PIDeepONet.ipynb +++ b/examples/tutorial/Tutorial_PIDeepONet.ipynb @@ -1,2131 +1,647 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "CzanhsB3YLBe" - }, - "source": [ - "# Physics-informed DeepONet: Solving a ODE for different right hand sides\n", - "In this notebook, we present an introduction to the physics-informed DeepONet [(paper)](https://arxiv.org/abs/2103.10974) utilities of TorchPhysics.\n", - "As an example, we try to learn the integral operator of 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$. Before describing the implementation in TorchPhysics we give a short recall of DeepONets.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "bKeJnQz4Yftw" - }, - "source": [ - "# Recall of Deep Operator Networks (DeepONets)\n", - "\n", - "We wish to learn the solution $u_f:[0,1]\\to \\mathbb{R}$ for many different choices of functions $f:[0,1]\\to \\mathbb{R}$ by a DeepONet $\\varphi_{\\theta}.$\n", - "The construction of DeepOnets is described in what follows:\n", - "\n", - "1) The basic idea is to represent $u_f$ as a linear combination of neural networks $\\varphi_i:[0,1]\\to \\mathbb{R}$\n", - "$$\n", - "u_f(t) \\approx \\sum_{i=1}^n c_i(f) \\varphi_i(t),\n", - "$$\n", - "where the coefficients $c_i(f)$ depend on the parameter function $f$ that leads to the solution $u_f$ of the ODE above.\n", - "\n", - "2) We would wish to replace $c_i(f)$ by a neural network, too. However, we cannot use a function $f$ as an input of a neural network. Instead, we collect finitely many information about $f$ by sampling $f$ at sampling points $t_1, ..., t_k$. These serve as inputs of neural networks $\\psi_i$ for approximating the coefficients\n", - "$$\n", - "c_i(f) \\approx \\psi_i( f(t_1), ..., f(t_k) ).\n", - "$$\n", - "\n", - "3) A DeepONet $\\varphi_\\theta$ is hence defined as\n", - "$$\n", - "\\varphi_\\theta(f,t) := \\sum_{i=1}^n \\psi_i( f(t_1),...,f(t_k) ) \\varphi_i(t) ≈u_f(t).\n", - "$$\n", - "Typically, all $\\psi_i$ are collected within a single neural network, the so-called branch net $\\varphi_{branch}:[0,1] \\to \\mathbb{R}^n$, whose output coordinates just represent the $\\psi_i$. Similarly, the $\\varphi_i$ are represented by a so-called trunk net $\\varphi_{trunk}:[0,1] \\to \\mathbb{R}^n$.\n", - "So the branch net receives only information about the parameter function $f$, whereas the input of the trunk net is the coordinate $t$ at which the solution $u_f$ is to be approximated.\n", - "Note that the sampling points $t_1, ..., t_k$ needs to be fixed beforehang and should not be changed for different $f$, simply to not confuse the branch net $\\varphi_{branch}$." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "mdaVk2063YCG" - }, - "source": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ulenDc9tYfv2" - }, - "source": [ - "# Physics-informed DeepONets in TorchPhysics\n", - "\n", - "The general structure of TorchPhysics still holds for DeepONet problems, so we can follow the same step-by-step recipe as in the [PINN-tutorials](https://torchphysics.de/tutorial).\n", - "However, we need some new concepts to define training functions of $f$. Here we show, how to:\n", - "\n", - "- create a function space for different training functions\n", - "- define a DeepONet-neural-network consisting of trunk and branch net\n", - "\n", - "and some additional details one has to consider." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "ge4lD3QIYLBf" - }, - "outputs": [], - "source": [ - "import os\n", - "import torch\n", - "import torchphysics as tp\n", - "import pytorch_lightning as pl" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "-TnwJNYRs0nA" - }, - "source": [ - "## Step 1: Specify spaces and domains\n", - "As in the PINN tutorials we need to specify the input and output spaces of the solution functions $u_f:[0,1]\\to \\mathbb{R}$." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "0ewY_QuetJmo" - }, - "outputs": [], - "source": [ - "# Input and output spaces\n", - "T = tp.spaces.R1('t') # input variable\n", - "U = tp.spaces.R1('u') # output variable\n", - "\n", - "# Domain of u_f\n", - "T_int = tp.domains.Interval(T, 0, 1)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "8zhCYNVZtg-5" - }, - "source": [ - "The DeepONet tries to learn many different $u_f$ for parameter functions $f$. Therefore, we need to define a set of functions $f$ that will be used for training the DeepONet.\n", - "We consider the function set that consist of the following parameterized functions for $k\\in [0,6]$\n", - "$$\n", - "f_1(t, k) = kt,\\\\\n", - "f_2(t, k) = kt^2,\\\\\n", - "f_3(t, k) = k\\cos(kt).\n", - "$$" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "id": "LoCmJVNd9vvc" - }, - "outputs": [], - "source": [ - "def f1(k, t):\n", - " return k*t\n", - "def f2(k, t):\n", - " return k*t**2\n", - "def f3(k, t):\n", - " return k*torch.cos(k*t)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "PzMYI0iX9sXr" - }, - "source": [ - "In order to construct this function set in TorchPhysics, we need to create input and output spaces for these functions $f_i$, similar to what we did with $u_f$. Here, also the parameter $k$ is treated as an input. Note that for the input variable $t$ we do not specify a space and domain again, as we already did that above." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "id": "UzKytihtYLBg" - }, - "outputs": [], - "source": [ - "# Input and output spaces for the parameterized functions f_1, f_2, f_3\n", - "K = tp.spaces.R1('k') # Parameter\n", - "F = tp.spaces.R1('f') # Function output space name\n", - "# Domains\n", - "K_int = tp.domains.Interval(K, 0, 6) # Parameters will be scalar values" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "lF6ufyUE8B4M" - }, - "source": [ - "If different ranges for $k$ were to be used for different $f_i$, one would have needed to create multiple parameter spaces and domains.\n", - "\n", - "The function set of all $f_i$ for all $k\\in [0,6]$ is considered as a domain object in TorchPhysics, simply because this set serves as the input for the branch net of the DeepONet. The constructor of CustomFunctionSet(...) receives three inputs:\n", - "- A function space that specifies the domain and output space of the functions $f_i:[0,1] \\to \\mathbb{R}$;\n", - "- A sampler for providing different parameters $k$;\n", - "- The parameterized function $f_i$ that represents the function set.\n", - "\n", - "We first create function sets for all $f_i$ individually and afterwards obtain the union by the \"+\" operator." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "kNyDfWJ3YLBh" - }, - "outputs": [], - "source": [ - "# Defining function set\n", - "Fn_space = tp.spaces.FunctionSpace(T_int, F)\n", - "\n", - "param_sampler = tp.samplers.RandomUniformSampler(K_int, n_points=40)\n", - "\n", - "Fn_set_1 = tp.domains.CustomFunctionSet(Fn_space, param_sampler, f1)\n", - "Fn_set_2 = tp.domains.CustomFunctionSet(Fn_space, param_sampler, f2)\n", - "Fn_set_3 = tp.domains.CustomFunctionSet(Fn_space, param_sampler, f3)\n", - "\n", - "Fn_set = Fn_set_1 + Fn_set_2 + Fn_set_3 # \"+\" computes the union of function sets" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "n4e7zKDW-5dz" - }, - "source": [ - "Mathematically, Fn_set represents the function set\n", - "$$\n", - "\\{ f_i(\\cdot , k): \\text{for } i=1,2,3 \\text{ and } k\\in [0,6] \\}.\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "fM4ALPl13dQW" - }, - "source": [ - "## Step 2: Define point samplers\n", - "As in the PINN tutorials we need to define samplers for the ODE condtion and the initial condition." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "QVYBUZM0AEjL" - }, - "outputs": [], - "source": [ - "sampler_ode_condition = tp.samplers.RandomUniformSampler(T_int, 1000)\n", - "\n", - "sampler_initial_condition = tp.samplers.RandomUniformSampler(T_int.boundary_left, 500)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "HOJ31RPpAYd7" - }, - "source": [ - "## Step 3: Define residual functions\n", - "Similar to $u$, the parameter function $f$ occuring in the ODE condition will already have been sampled when the residual functions are called. Therefore, we define the residual functions as:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "id": "qhtoY7msAffq" - }, - "outputs": [], - "source": [ - "def residual_ode_condition(u, t, f):\n", - " return tp.utils.grad(u, t) - f\n", - "\n", - "def residual_initial_condition(u):\n", - " return u" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "PWt7y2vLA2wK" - }, - "source": [ - "\n", - "## Step 4: Define DeepONet\n", - "\n", - "The branch net in TorchPhysics needs to know the function space the parameter functions $f$ belong to. Further, it needs to know the points $t_1,.,,,t_k$ at which these $f$ are to be sampled. These sampling points can just be obtained by for example a GridSampler. As mentioned in the recall, these sampling points should be fixed and never changed. Therefore, we need to make this sampler static." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "id": "hTW3VG7iYLBh" - }, - "outputs": [], - "source": [ - "# Branch net\n", - "branch_input_sampler = tp.samplers.GridSampler(T_int, 50).make_static() # hence, there will be 50 sampling points $t_j$\n", - "# We choose a fully connected network for the branch net, in TorchPhysics: FCBranchNet(...)\n", - "branch_net = tp.models.FCBranchNet(Fn_space, hidden=(50, 50), discretization_sampler=branch_input_sampler)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "F_nMeGdYD1rd" - }, - "source": [ - "Also for the trunk net we choose a fully connected network." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "id": "d1PDR5qIDdmr" - }, - "outputs": [], - "source": [ - "trunk_net = tp.models.FCTrunkNet(T, hidden=(30, 30))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "_RFcpvASD-qy" - }, - "source": [ - "The constructor of the DeepONet receives just the trunk net, the branch net, the output space of the solution functions $u_f$, as well as the output dimension $n$ of the branch and trunk nets. We set the output dimension to $50$. Having a look at the DeepONet recall again, this means that the DeepONet can represent a function vector space of dimension $\\leq 50$." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "id": "HgFlwDuBD9aT" - }, - "outputs": [], - "source": [ - "model = tp.models.DeepONet(trunk_net, branch_net, U, output_neurons=50)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "yCeOL7jFA9sr" - }, - "source": [ - "## Step 5: Create TorchPhysics Conditions\n", - "Almost done: We only need to define the TorchPhysics conditions for the ODE and initial condition. Since the DeepONet is to be trained physics-informed, we need to define PIDeepONetConditions." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "id": "jOUqZr8vYLBi" - }, - "outputs": [], - "source": [ - "# Conditions for the ODE problem\n", - "ode_condition = tp.conditions.PIDeepONetCondition(deeponet_model=model,\n", - " function_set=Fn_set,\n", - " input_sampler=sampler_ode_condition,\n", - " residual_fn=residual_ode_condition)\n", - "# Note: If logging via Tensorboard is desired, just add name='ode_condition' as an input of the PIDeepONetCondition. Works also for all other conditions, such as PINNCondition. \n", - "\n", - "initial_condition = tp.conditions.PIDeepONetCondition(deeponet_model=model,\n", - " function_set=Fn_set,\n", - " input_sampler=sampler_initial_condition,\n", - " residual_fn=residual_initial_condition)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "7ImcV0W8BZxj" - }, - "source": [ - "# Training" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 344, - "referenced_widgets": [ - "eab3e0cf876e42a9bd7118bbf01417b3", - "1fbef4dff38943dd9334bcf8f98b9025", - "96df4b367e0147b4b0873178c2c6ddee", - "febbf813f7344eea93d68337a3fb3ce4", - "accbf70574ba461ea61bb62e4e649841", - "bf5c85326d0746f1a75f5ba124b04b2b", - "42e76e3b8ed3484f92869e7253b6f65b", - "035d64de4ffe4480a693d787e4cf3372", - "b63aa5f44deb4e35bcc74e26f581bb08", - "bea3f5a98c8d4a3a97b8b946e0cd4d57", - "d12decf7d62840b79bc0dd22184d2260", - "cd63d468874441ada619c005aea50780", - "c18d459cfb3e4e158e7f2944b667144e", - "40845e140d324680a70af6ff099c5fd0", - "539d5cad38824eaca6c808263ff39248", - "2bb0e93f1fcc4557a9e28acbfb1ca5ff", - "0b5a790579e3404680f9e0eee3a8cff2", - "cd11a8ea139a42249b0907737559a3ad", - "0d2180d103794cc8a90a46884fc402cc", - "e72a8bd17e234b979a6423515ec8676d", - "392f12bd38d54b40a0a06309f3ddd7fd", - "e91087442a97426892598e42e19a0368" - ] - }, - "id": "CmoY6mXyYLBj", - "outputId": "e309c69b-b892-4a69-9f5c-f2bae80bfbf2", - "tags": [ - "outputPrepend" - ] - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pytorch_lightning.utilities.rank_zero:GPU available: True (cuda), used: True\n", - "INFO:pytorch_lightning.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n", - "INFO:pytorch_lightning.utilities.rank_zero:HPU available: False, using: 0 HPUs\n", - "INFO:pytorch_lightning.accelerators.cuda:LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "INFO:pytorch_lightning.callbacks.model_summary:\n", - " | Name | Type | Params | Mode \n", - "--------------------------------------------------------\n", - "0 | train_conditions | ModuleList | 10.2 K | train\n", - "1 | val_conditions | ModuleList | 0 | train\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", - "19 Modules in train mode\n", - "0 Modules in eval mode\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "eab3e0cf876e42a9bd7118bbf01417b3", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: | | 0/? [00:00" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "k0 = 1.16\n", - "def f(t):\n", - " return k0 * t**2\n", - "\n", - "def F(t): # ground truth solution u_f\n", - " return k0/3.0 * t**3\n", - "\n", - "model.fix_branch_input(f)\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": 16, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 447 - }, - "id": "5lqtQM9WYLBl", - "outputId": "24c26ba5-8390-48ef-b2e4-27f6f5b84aca" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "k0 = 2.14\n", - "def f(t):\n", - " return k0 * torch.cos(k0*t)\n", - "\n", - "def F(t): # ground truth solution u_f\n", - " return torch.sin(k0*t)\n", - "\n", - "model.fix_branch_input(f)\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'])" - ] + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "CzanhsB3YLBe" + }, + "source": [ + "# Physics-informed DeepONet: Solving a ODE for different right hand sides\n", + "In this notebook, we present an introduction to the physics-informed DeepONet [(paper)](https://arxiv.org/abs/2103.10974) utilities of TorchPhysics.\n", + "As an example, we try to learn the integral operator of 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$. Before describing the implementation in TorchPhysics we give a short recall of DeepONets.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bKeJnQz4Yftw" + }, + "source": [ + "# Recall of Deep Operator Networks (DeepONets)\n", + "\n", + "We wish to learn the solution $u_f:[0,1]\\to \\mathbb{R}$ for many different choices of functions $f:[0,1]\\to \\mathbb{R}$ by a DeepONet $\\varphi_{\\theta}.$\n", + "The construction of DeepOnets is described in what follows:\n", + "\n", + "1) The basic idea is to represent $u_f$ as a linear combination of neural networks $\\varphi_i:[0,1]\\to \\mathbb{R}$\n", + "$$\n", + "u_f(t) \\approx \\sum_{i=1}^n c_i(f) \\varphi_i(t),\n", + "$$\n", + "where the coefficients $c_i(f)$ depend on the parameter function $f$ that leads to the solution $u_f$ of the ODE above.\n", + "\n", + "2) We would wish to replace $c_i(f)$ by a neural network, too. However, we cannot use a function $f$ as an input of a neural network. Instead, we collect finitely many information about $f$ by sampling $f$ at sampling points $t_1, ..., t_k$. These serve as inputs of neural networks $\\psi_i$ for approximating the coefficients\n", + "$$\n", + "c_i(f) \\approx \\psi_i( f(t_1), ..., f(t_k) ).\n", + "$$\n", + "\n", + "3) A DeepONet $\\varphi_\\theta$ is hence defined as\n", + "$$\n", + "\\varphi_\\theta(f,t) := \\sum_{i=1}^n \\psi_i( f(t_1),...,f(t_k) ) \\varphi_i(t) ≈u_f(t).\n", + "$$\n", + "Typically, all $\\psi_i$ are collected within a single neural network, the so-called branch net $\\varphi_{branch}:[0,1] \\to \\mathbb{R}^n$, whose output coordinates just represent the $\\psi_i$. Similarly, the $\\varphi_i$ are represented by a so-called trunk net $\\varphi_{trunk}:[0,1] \\to \\mathbb{R}^n$.\n", + "So the branch net receives only information about the parameter function $f$, whereas the input of the trunk net is the coordinate $t$ at which the solution $u_f$ is to be approximated.\n", + "Note that the sampling points $t_1, ..., t_k$ needs to be fixed beforehang and should not be changed for different $f$, simply to not confuse the branch net $\\varphi_{branch}$." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ulenDc9tYfv2" + }, + "source": [ + "# Physics-informed DeepONets in TorchPhysics\n", + "\n", + "The general structure of TorchPhysics still holds for DeepONet problems, so we can follow the same step-by-step recipe as in the [PINN-tutorials](https://torchphysics.de/tutorial).\n", + "However, we need some new concepts to define training functions of $f$. Here we show, how to:\n", + "\n", + "- create a function space for different training functions\n", + "- define a DeepONet-neural-network consisting of a trunk and branch net\n", + "\n", + "and some additional details one has to consider." + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": { + "id": "ge4lD3QIYLBf" + }, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "import torchphysics as tp\n", + "import pytorch_lightning as pl" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-TnwJNYRs0nA" + }, + "source": [ + "## Step 1: Specify spaces and domains\n", + "As in the PINN tutorials we need to specify the input and output spaces of the solution functions $u_f:[0,1]\\to \\mathbb{R}$." + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": { + "id": "0ewY_QuetJmo" + }, + "outputs": [], + "source": [ + "# Input and output spaces\n", + "T = tp.spaces.R1('t') # input variable\n", + "U = tp.spaces.R1('u') # output variable\n", + "\n", + "# Domain of u_f\n", + "T_interval = tp.domains.Interval(T, 0, 1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8zhCYNVZtg-5" + }, + "source": [ + "The DeepONet tries to learn $u_f$ for many different parameter functions $f$. Therefore, we need to define a set of functions $f$ that will be used for training the DeepONet.\n", + "We consider the function set that consist of the following parameterized functions for $k\\in [0,6]$\n", + "$$\n", + "f_1(t, k) = kt,\\\\\n", + "f_2(t, k) = kt^2,\\\\\n", + "f_3(t, k) = k\\cos(kt).\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "id": "LoCmJVNd9vvc" + }, + "outputs": [], + "source": [ + "def f1(k, t):\n", + " return k*t\n", + "def f2(k, t):\n", + " return k*t**2\n", + "def f3(k, t):\n", + " return k*torch.cos(k*t)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PzMYI0iX9sXr" + }, + "source": [ + "In order to construct this function set in TorchPhysics, we need to create input and output spaces for these functions $f_i$, similar to what we did with $u_f$. Here, also the parameter $k$ is treated as an input. Note that for the input variable $t$ we do not specify a space and domain again, as we already did that above." + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": { + "id": "UzKytihtYLBg" + }, + "outputs": [], + "source": [ + "# Input and output spaces for the parameterized functions f_1, f_2, f_3\n", + "K = tp.spaces.R1('k') # Parameter\n", + "F = tp.spaces.R1('f') # Function output space name\n", + "# Domains\n", + "K_interval = tp.domains.Interval(K, 0, 6) # Parameters will be scalar values" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lF6ufyUE8B4M" + }, + "source": [ + "If different ranges for $k$ were to be used for different $f_i$, one would have needed to create multiple parameter spaces and domains.\n", + "\n", + "The function set of all $f_i$ for all $k\\in [0,6]$ is considered as a domain object in TorchPhysics, simply because this set serves as the input for the branch net of the DeepONet. The constructor of CustomFunctionSet(...) receives three inputs:\n", + "- A function space that specifies the input and output spaces of the functions $f_i:[0,1]\\subset \\mathbb{R} \\to \\mathbb{R}$;\n", + "- A sampler for providing different parameters $k$;\n", + "- The parameterized function $f_i$ that represents the function set.\n", + "\n", + "We first create function sets for all $f_i$ individually and afterwards obtain the union by the \"append()\" method of the FunctionSet class." + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "id": "kNyDfWJ3YLBh" + }, + "outputs": [], + "source": [ + "# Defining function set\n", + "Fn_space = tp.spaces.FunctionSpace(T, F)\n", + "\n", + "param_sampler = tp.samplers.RandomUniformSampler(K_interval, n_points=5000)\n", + "\n", + "Fn_set_1 = tp.domains.CustomFunctionSet(Fn_space, param_sampler, f1)\n", + "Fn_set_2 = tp.domains.CustomFunctionSet(Fn_space, param_sampler, f2)\n", + "Fn_set_3 = tp.domains.CustomFunctionSet(Fn_space, param_sampler, f3)\n", + "\n", + "Fn_set = Fn_set_1.append(Fn_set_2).append(Fn_set_3) # A.append(B) computes the union of the function sets A and B." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "n4e7zKDW-5dz" + }, + "source": [ + "Mathematically, Fn_set represents the function set\n", + "$$\n", + "\\{ f_i(\\cdot , k): \\text{for } i=1,2,3 \\text{ and } k\\in [0,6] \\}.\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fM4ALPl13dQW" + }, + "source": [ + "## Step 2: Define point samplers\n", + "As in the PINN tutorials we need to define samplers for the ODE condtion and the initial condition." + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": { + "id": "QVYBUZM0AEjL" + }, + "outputs": [], + "source": [ + "sampler_ode_condition = tp.samplers.RandomUniformSampler(T_interval, 1000)\n", + "\n", + "sampler_initial_condition = tp.samplers.RandomUniformSampler(T_interval.boundary_left, 500)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "During the training, functions from the functions set \"Fn_set\" need to be selected/sampled. This is done by a \"FunctionSamplerRandomUniform\", which randomly selects functions from the function set." + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "# Each time the function sampler is called, we want to randomly select n_functions=5000 functions from the function set Fn_set.\n", + "# Once created, it may be beneficial to reuse these functions for the next 100 calls of the function sampler before generating new ones\n", + "# This can simply be achieved by setting specify function_creation_interval=100.\n", + "function_sampler = tp.samplers.FunctionSamplerRandomUniform(\n", + " n_functions=5000, \n", + " function_set=Fn_set, \n", + " function_creation_interval=100\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HOJ31RPpAYd7" + }, + "source": [ + "## Step 3: Define residual functions\n", + "Similar to $u$, the parameter function $f$ occuring in the ODE condition will already have been sampled when the residual functions are called. Therefore, we define the residual functions as:" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": { + "id": "qhtoY7msAffq" + }, + "outputs": [], + "source": [ + "def residual_ode_condition(u, t, f):\n", + " return tp.utils.grad(u, t) - f\n", + "\n", + "def residual_initial_condition(u):\n", + " return u" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PWt7y2vLA2wK" + }, + "source": [ + "\n", + "## Step 4: Define DeepONet\n", + "\n", + "The branch net in TorchPhysics needs to know the function space the parameter functions $f$ belong to. Further, it needs to know the points $t_1,.,,,t_k$ at which these $f$ are to be sampled. As mentioned in the recall, these sampling points should be fixed and never changed. These sampling points, called \"time_grid\" below, can just be obtained by for example a GridSampler and using the\"sample_points()\" method." + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": { + "id": "hTW3VG7iYLBh" + }, + "outputs": [], + "source": [ + "# Branch net\n", + "time_grid = tp.samplers.GridSampler(T_interval, 30).sample_points()\n", + "# We choose a fully connected network for the branch net, in TorchPhysics: FCBranchNet(...)\n", + "branch_net = tp.models.FCBranchNet(Fn_space, hidden=(20, 20), grid=time_grid)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F_nMeGdYD1rd" + }, + "source": [ + "Also for the trunk net we choose a fully connected network." + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": { + "id": "d1PDR5qIDdmr" + }, + "outputs": [], + "source": [ + "trunk_net = tp.models.FCTrunkNet(T, hidden=(10, 10), default_trunk_input=time_grid)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_RFcpvASD-qy" + }, + "source": [ + "The constructor of the DeepONet receives just the trunk net, the branch net, the output space of the solution functions $u_f$, as well as the output dimension $n$ of the branch and trunk nets. We set the output dimension to $30$. Having a look at the DeepONet recall again, this means that the DeepONet can represent a function vector space of dimension $\\leq 30$." + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": { + "id": "HgFlwDuBD9aT" + }, + "outputs": [], + "source": [ + "deeponet = tp.models.DeepONet(trunk_net, branch_net, output_space=U, output_neurons=30)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yCeOL7jFA9sr" + }, + "source": [ + "## Step 5: Create TorchPhysics Conditions\n", + "Almost done: We only need to define the TorchPhysics conditions for the ODE and initial condition. Since the DeepONet is to be trained physics-informed, we need to define PIDeepONetConditions.\n", + "The main inputs for the constructor of such a condition are:\n", + "- deeponet_model: the model that should be trained on this condition;\n", + "- branch_function_sampler: the function sampler that generates functions $f_i$ as inputs of the branch net;\n", + "- trunk_points_sampler: samples points at which the ode condition should be satisfied. These are fed into the trunk networks;\n", + "- residual_fn: residual function for the respective pde/ode condition." + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": { + "id": "jOUqZr8vYLBi" + }, + "outputs": [], + "source": [ + "# Conditions for the ODE problem\n", + "ode_condition = tp.conditions.PIDeepONetCondition(deeponet_model=deeponet,\n", + " branch_function_sampler=function_sampler,\n", + " trunk_points_sampler=sampler_ode_condition,\n", + " residual_fn=residual_ode_condition)\n", + "# Note: If logging via Tensorboard is desired, just add name='ode_condition' as an input of the PIDeepONetCondition. Works also for all other conditions, such as PINNCondition. \n", + "\n", + "initial_condition = tp.conditions.PIDeepONetCondition(deeponet_model=deeponet,\n", + " branch_function_sampler=function_sampler,\n", + " trunk_points_sampler=sampler_initial_condition,\n", + " residual_fn=residual_initial_condition)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7ImcV0W8BZxj" + }, + "source": [ + "# Training" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 344, + "referenced_widgets": [ + "eab3e0cf876e42a9bd7118bbf01417b3", + "1fbef4dff38943dd9334bcf8f98b9025", + "96df4b367e0147b4b0873178c2c6ddee", + "febbf813f7344eea93d68337a3fb3ce4", + "accbf70574ba461ea61bb62e4e649841", + "bf5c85326d0746f1a75f5ba124b04b2b", + "42e76e3b8ed3484f92869e7253b6f65b", + "035d64de4ffe4480a693d787e4cf3372", + "b63aa5f44deb4e35bcc74e26f581bb08", + "bea3f5a98c8d4a3a97b8b946e0cd4d57", + "d12decf7d62840b79bc0dd22184d2260", + "cd63d468874441ada619c005aea50780", + "c18d459cfb3e4e158e7f2944b667144e", + "40845e140d324680a70af6ff099c5fd0", + "539d5cad38824eaca6c808263ff39248", + "2bb0e93f1fcc4557a9e28acbfb1ca5ff", + "0b5a790579e3404680f9e0eee3a8cff2", + "cd11a8ea139a42249b0907737559a3ad", + "0d2180d103794cc8a90a46884fc402cc", + "e72a8bd17e234b979a6423515ec8676d", + "392f12bd38d54b40a0a06309f3ddd7fd", + "e91087442a97426892598e42e19a0368" + ] + }, + "id": "CmoY6mXyYLBj", + "outputId": "e309c69b-b892-4a69-9f5c-f2bae80bfbf2", + "tags": [ + "outputPrepend" + ] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "HPU available: False, using: 0 HPUs\n", + "/home/s_e8mv8u/anaconda3/envs/torchphysics/lib/python3.9/site-packages/pytorch_lightning/callbacks/model_checkpoint.py:654: Checkpoint directory /home/s_e8mv8u/PhD/torchphysics/examples/tutorial/checkpoints exists and is not empty.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3,4,5,6,7]\n", + "\n", + " | Name | Type | Params | Mode \n", + "--------------------------------------------------------\n", + "0 | train_conditions | ModuleList | 2.1 K | train\n", + "1 | val_conditions | ModuleList | 0 | train\n", + "--------------------------------------------------------\n", + "2.1 K Trainable params\n", + "0 Non-trainable params\n", + "2.1 K Total params\n", + "0.009 Total estimated model params size (MB)\n", + "19 Modules in train mode\n", + "0 Modules in eval mode\n", + "/home/s_e8mv8u/anaconda3/envs/torchphysics/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:424: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n", + "/home/s_e8mv8u/anaconda3/envs/torchphysics/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:424: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d791360d7f534d47812c177e26757678", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "k0 = 1.16\n", + "def f(t):\n", + " return k0 * t**2\n", + "\n", + "def F(t): # ground truth solution u_f\n", + " return k0/3.0 * t**3\n", + "\n", + "deeponet.fix_branch_input(f)\n", + "grid_sampler = tp.samplers.GridSampler(T_interval, 500)\n", + "grid_points = grid_sampler.sample_points().as_tensor\n", + "out = deeponet(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'])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 447 + }, + "id": "5lqtQM9WYLBl", + "outputId": "24c26ba5-8390-48ef-b2e4-27f6f5b84aca" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "k0 = 2.14\n", + "def f(t):\n", + " return k0 * torch.cos(k0*t)\n", + "\n", + "def F(t): # ground truth solution u_f\n", + " return torch.sin(k0*t)\n", + "\n", + "deeponet.fix_branch_input(f)\n", + "grid_sampler = tp.samplers.GridSampler(T_interval, 500)\n", + "grid_points = grid_sampler.sample_points().as_tensor\n", + "out = deeponet(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'])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "torchphysics", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 0 + "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.20" + } + }, + "nbformat": 4, + "nbformat_minor": 0 } diff --git a/examples/tutorial/Tutorial_Simple_ODE.ipynb b/examples/tutorial/Tutorial_Simple_ODE.ipynb index 6cd23050..623e98a1 100644 --- a/examples/tutorial/Tutorial_Simple_ODE.ipynb +++ b/examples/tutorial/Tutorial_Simple_ODE.ipynb @@ -1,1354 +1,705 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "id": "1ef6d147-2dd4-4547-9fb6-79b3758d7350", - "metadata": { - "id": "1ef6d147-2dd4-4547-9fb6-79b3758d7350" - }, - "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": "bTGz6NV4_Jzb", - "metadata": { - "id": "bTGz6NV4_Jzb" - }, - "source": [ - "# Physics Informed Neural Networks (PINNs) in TorchPhysics\n", - "In this tutorial we present a first basic example of solving a simple ODE with an initial condition 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 consider the simple ODE:\n", - "$$\n", - "\\begin{cases}\n", - "\\frac{\\partial}{\\partial t} u(t) &= u(t) &&\\text{ on the interval } (0, 2), \\\\\n", - "u(t) &= u_0 &&\\text{ for } t\\in \\{ 0\\}.\n", - "\\end{cases}\n", - "$$\n", - "In the following we want to learn the solution function $u(t) = u_0 e^t$, where we set the initial value to $u_0=2$." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "d6b5fdd2-67c1-4f7e-a185-9d515fb9f3f8", - "metadata": { - "id": "d6b5fdd2-67c1-4f7e-a185-9d515fb9f3f8" - }, - "outputs": [], - "source": [ - "u_0 = 2 # initial value" - ] - }, - { - "cell_type": "markdown", - "id": "8da6279e-83c2-41ed-a56b-453b21f05d11", - "metadata": { - "id": "8da6279e-83c2-41ed-a56b-453b21f05d11" - }, - "source": [ - "## Recall PINNs\n", - "The goal is to find a neural network $u_\\theta:[0, 2]\\to \\mathbb{R}$, which approximately satisfies the two conditions of the ODE problem above, where $\\theta$ are the trainable parameters of the neural network.\n", - "Let us shortly recall the main idea behind PINNs.\n", - "\n", - "The residuals are denoted by\n", - "$$\n", - "\\begin{align}\n", - "&\\text{1) Residual of the ODE condition: } &&R_1(u, t) := \\frac{\\partial^2}{\\partial t^2} u(t) - u(t) &&&\\text{ for } t\\in (0,2),\\\\\n", - "&\\text{2) Residual of the initial condition: } &&R_2(u, t) := u(t) - u_0 &&& \\text{ for } t\\in \\{0\\}.\n", - "\\end{align}\n", - "$$\n", - "Continuing with the PINN approach, points are sampled in the domains corresponding to each condition. In our example:\n", - "$$\n", - "\\begin{align}\n", - "&\\text{1) } &&\\big(t_i^{(1)} \\big)_i &&&\\in (0, 2),\\\\\n", - "&\\text{2) } &&\\big(t_j^{(2)} \\big)_j &&&\\in \\{0\\}.\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, t_i^{(1)}) \\big \\vert^2 + \\sum_j \\big\\vert R_2(u_\\theta, t_j^{(2)}) \\big \\vert^2,\n", - "\\end{align}\n", - "$$\n", - "that is, the residuals are minimized with respect to the $l_2$-norm." - ] - }, - { - "cell_type": "markdown", - "id": "8f0db4a0-cace-4d21-845f-f34680880d7d", - "metadata": { - "id": "8f0db4a0-cace-4d21-845f-f34680880d7d" - }, - "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://boschresearch.github.io/torchphysics/tutorial/tutorial_start.html) or [examples](https://boschresearch.github.io/torchphysics/examples.html)." - ] - }, - { - "cell_type": "markdown", - "id": "e8fe0433-82b7-4093-8f6f-8adf7e46ff5b", - "metadata": { - "id": "e8fe0433-82b7-4093-8f6f-8adf7e46ff5b" - }, - "source": [ - "### Step 1: Specify spaces and domains\n", - "The domain $I=(0, 2)$ is a subset of the space $\\mathbb{R}$, whereas the range space of the solution function $u$ is $\\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. We need an interval domain, which is an open interval by default. For creating complexer domains please have a look at the [domain-tutorial](https://boschresearch.github.io/torchphysics/tutorial/tutorial_domain_basics.html)." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "6af0dba0-d481-4566-a8b7-244098eee713", - "metadata": { - "id": "6af0dba0-d481-4566-a8b7-244098eee713" - }, - "outputs": [], - "source": [ - "# Input and output spaces\n", - "T = tp.spaces.R1('t')\n", - "U = tp.spaces.R1('u')\n", - "\n", - "# Domain\n", - "I = tp.domains.Interval(space=T, lower_bound=0, upper_bound=2)" - ] - }, - { - "cell_type": "markdown", - "id": "a1676bc3-8dab-4ce4-84ff-f8fc29e8b829", - "metadata": { - "id": "a1676bc3-8dab-4ce4-84ff-f8fc29e8b829" - }, - "source": [ - "### Step 2: Define point samplers for different subsets of [0, 2]\n", - "As mentioned in the PINN recall, it will be necessary to sample points in different subsets of the full domain $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://boschresearch.github.io/torchphysics/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", - "The ODE condition 1) should hold for points in the domain $I=(0, 2)$. We have defined this domain already in Step 1, so that we can define a point sampler:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "d020f7f4-c286-466f-928d-1f80ee64c53f", - "metadata": { - "id": "d020f7f4-c286-466f-928d-1f80ee64c53f" - }, - "outputs": [], - "source": [ - "sampler_ode_condition = tp.samplers.RandomUniformSampler(domain=I, n_points=150)" - ] - }, - { - "cell_type": "markdown", - "id": "c9f72b70-0e87-466f-a7c0-0e1f194745cc", - "metadata": { - "id": "c9f72b70-0e87-466f-a7c0-0e1f194745cc" - }, - "source": [ - "Next, let us define samplers for the initial condition. This condition should hold on the domain $\\{0\\}$, which is the left boundary of the interval $I=(0,2)$. All tp.domains.Interval objects have the attribute \"left_boundary\", an instance of TorchPhysics BoundaryDomain class, a subclass of the Domain class. This allows to construct a sampler for this initial condition." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "e780f5fa-5ebf-4731-8568-77116ea039f6", - "metadata": { - "id": "e780f5fa-5ebf-4731-8568-77116ea039f6" - }, - "outputs": [], - "source": [ - "domain_initial_condition = I.boundary_left\n", - "sampler_initial_condition = tp.samplers.RandomUniformSampler(domain_initial_condition, 50)" - ] - }, - { - "cell_type": "markdown", - "id": "7750bf6b-30ec-4ca9-8f37-9699439d0d22", - "metadata": { - "id": "7750bf6b-30ec-4ca9-8f37-9699439d0d22" - }, - "source": [ - "For more detailed information on the functionality of TorchPysics samplers, please have a look at the further [tutorials](https://torchphysics.de/tutorial), [examples](https://boschresearch.github.io/torchphysics/examples.html) or the in-depth [sampler-tutorial](https://boschresearch.github.io/torchphysics/tutorial/sampler_tutorial.html)." - ] - }, - { - "cell_type": "markdown", - "id": "6b1b87f9-b6d6-44ec-8fb5-833ab466d89b", - "metadata": { - "id": "6b1b87f9-b6d6-44ec-8fb5-833ab466d89b" - }, - "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$ and $R_2$ vanish.\n", - "\n", - "Let us have a look at $R_1$, the residual for the ODE condition, the way it is defined in the PINNs recall above. The inputs of $R_1$ are the coordinate $t\\in(0,2)$, but also $u_\\theta$, which is itself a function of $t$. In TorchPhysics, the evaluation of the network $u_\\theta$ at $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 tuples $(u, t)$, where $u:=u_\\theta(t)$.\n", - "\n", - "More precisely, $u$ will be a torch.tensor of shape (n_points, 1) and $t$ of shape (n_points, 1), where n_points is the number of triples $(u,t)$ for which the residual should be computed.\n", - "\n", - "For the residual $R_1$ it is required to compute the first derivative (gradient) of $u$ with respect to $t$. This differential operator, among others - see the [utils-tutorial](https://boschresearch.github.io/torchphysics/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": 7, - "id": "c29f3f92-d613-470f-ab74-9369e071ea04", - "metadata": { - "id": "c29f3f92-d613-470f-ab74-9369e071ea04" - }, - "outputs": [], - "source": [ - "def residual_ode_condition(u, t):\n", - " return u - tp.utils.grad(u, t)" - ] - }, - { - "cell_type": "markdown", - "id": "e444a2e5-6fc6-4124-894c-1ba987153241", - "metadata": { - "id": "e444a2e5-6fc6-4124-894c-1ba987153241" - }, - "source": [ - "For the computation of the residual $R_2$ of the initial condition, the coordinate $t\\in \\{0\\}$ is not required, since $u$ is already the evaluation of the network at these sampling points. Therefore, we can conveniently omit them as input parameters." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "65954de9-4c80-4d2a-be6e-0cd16ab82596", - "metadata": { - "id": "65954de9-4c80-4d2a-be6e-0cd16ab82596" - }, - "outputs": [], - "source": [ - "def residual_initial_condition(u):\n", - " return u - u_0" - ] - }, - { - "cell_type": "markdown", - "id": "0cc89ada-310b-4a84-bcc0-77baa7afca2c", - "metadata": { - "id": "0cc89ada-310b-4a84-bcc0-77baa7afca2c" - }, - "source": [ - "### Step 4: Define Neural Network\n", - "At this point, let us define the model $u_\\theta:[0,2]\\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 the [model-tutorial](https://boschresearch.github.io/torchphysics/tutorial/model_creation.html).\n", - "There are also a bunch of predefined neural networks or single layers available. In this tutorial we consider a very simple neural network, a FNO consisting of three hidden layers with $50, 50$ and $50$ neurons, respectively.:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "bdef3d80-90e6-47aa-95ce-6d735fd03f36", - "metadata": { - "id": "bdef3d80-90e6-47aa-95ce-6d735fd03f36" - }, - "outputs": [], - "source": [ - "model = tp.models.FCN(input_space=T, output_space=U, hidden = (50,50,50))" - ] - }, - { - "cell_type": "markdown", - "id": "17e3f8ab-bd6c-4f4f-94a6-030930458c0c", - "metadata": { - "id": "17e3f8ab-bd6c-4f4f-94a6-030930458c0c" - }, - "source": [ - "### Step 5: Create TorchPhysics Conditions\n", - "Let us sum up what we have done so far: For the ODE and initial condition, 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://boschresearch.github.io/torchphysics/tutorial/condition_tutorial.html) for further information." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "008c09a7-81f8-41b5-8c10-3892812740ad", - "metadata": { - "id": "008c09a7-81f8-41b5-8c10-3892812740ad" - }, - "outputs": [], - "source": [ - "ode_condition = tp.conditions.PINNCondition(module =model,\n", - " sampler =sampler_ode_condition,\n", - " residual_fn=residual_ode_condition)\n", - "\n", - "initial_condition = tp.conditions.PINNCondition(module =model,\n", - " sampler =sampler_initial_condition,\n", - " residual_fn=residual_initial_condition)" - ] - }, - { - "cell_type": "markdown", - "id": "5cd77316-3c78-4bf1-b639-9ccb7070af2d", - "metadata": { - "id": "5cd77316-3c78-4bf1-b639-9ccb7070af2d" - }, - "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 ode_condition at points $(t_i)_i$ in $I=(0,2)$ will return\n", - "$$\n", - "\\begin{align}\n", - "\\sum_i \\big \\vert R_1(u_\\theta, t_i) \\big \\vert^2,\n", - "\\end{align}\n", - "$$\n", - "where $R_1$ is the residual function for the ODE 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": { - "id": "2e0fad4c-2cfd-4c10-8e2f-0a3702a2eeac" - }, - "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/boschresearch/torchphysics/blob/main/examples/pinn/interface-jump.ipynb) to train different networks for different conditions of the PDE problem." - ] - }, - { - "cell_type": "markdown", - "id": "31d80c43-5879-401c-8212-0e4a5fd6514c", - "metadata": { - "id": "31d80c43-5879-401c-8212-0e4a5fd6514c" - }, - "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": 11, - "id": "bb76e892-bf53-4a01-adc5-74dddb770525", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "bb76e892-bf53-4a01-adc5-74dddb770525", - "outputId": "ca750735-3e1e-4fcc-ca59-e020d6131434" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "GPU available: False\n" - ] - } - ], - "source": [ - "import pytorch_lightning as pl\n", - "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\" if torch.cuda.is_available() else \"0\"\n", - "\n", - "print (\"GPU available: \" + str(torch.cuda.is_available()))" - ] - }, - { - "cell_type": "markdown", - "id": "1639cf38-835b-4571-b0c5-7ef0d130c2df", - "metadata": { - "id": "1639cf38-835b-4571-b0c5-7ef0d130c2df" - }, - "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": 12, - "id": "ea27b608-e319-4fac-85c1-5984f2d043c6", - "metadata": { - "id": "ea27b608-e319-4fac-85c1-5984f2d043c6" - }, - "outputs": [], - "source": [ - "training_conditions = [ode_condition, initial_condition]" - ] - }, - { - "cell_type": "markdown", - "id": "e024913e-e10e-4387-b390-165e77c8524b", - "metadata": { - "id": "e024913e-e10e-4387-b390-165e77c8524b" - }, - "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." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "b1848d26-ea33-400c-84be-2291429e8065", - "metadata": { - "id": "b1848d26-ea33-400c-84be-2291429e8065" - }, - "outputs": [], - "source": [ - "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.001)" - ] - }, - { - "cell_type": "markdown", - "id": "efcd0c8c-1ef2-45a0-bf00-de88201f3d03", - "metadata": { - "id": "efcd0c8c-1ef2-45a0-bf00-de88201f3d03" - }, - "source": [ - "Finally, we are able to create the Solver object, a Pytorch Lightning Module." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "4ea2cb3f-087c-4e03-aeb0-40318f556062", - "metadata": { - "id": "4ea2cb3f-087c-4e03-aeb0-40318f556062" - }, - "outputs": [], - "source": [ - "solver = tp.solver.Solver(train_conditions=training_conditions, optimizer_setting=optim)" - ] - }, - { - "cell_type": "markdown", - "id": "53dec402-5dd2-40f9-a405-5170d0cfcbd7", - "metadata": { - "id": "53dec402-5dd2-40f9-a405-5170d0cfcbd7" - }, - "source": [ - "Now, as usual, the training is done with a Pytorch Lightning Trainer object and its fit() method." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "9ea9431a-9ea4-4312-8869-af4c8c4733a4", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 347, - "referenced_widgets": [ - "e9e9c3f6752640deb4d7f2791a8a329e", - "3b582cb05b834f60b6311fdbde240407", - "099fcd830e64454093b45f9ec3a9cc4a", - "d8e62d4fa51c4cedbff580f154dd3a17", - "fd6826c5f1a54e93ae8b6ab4d3d6e421", - "5f06b3f84db348c8b32ee48089e01f01", - "f3ebae78a3674c6c93fd64b3ed3e7542", - "cd0ca01f50124df0ac6c951d6d31ab85", - "58dbae958d11454e88b91efedb750d65", - "8ed5e770686f4cb78a0bc85a39ae4157", - "c733319a53f94defb4948ab02d05837c", - "fcd564594edd4d9582d3a4b3e212a3f2", - "6553e0de7efa42728366a465d83a948f", - "79b83887a2bb4248ae991970d6a274b1", - "e0ba190eae4e4d5192b5e1ce501af014", - "96e31c05ff4c4a87aef91967cf4292e1", - "1b5ba0b918de430da29cfca2f2a7afbf", - "b6390043fdd048849050dc7526dbe7df", - "b321cd7f2e454f21a4e1ea33c7ff4ce3", - "4250369b168442daa28a85e459fd788e", - "8f703e85f7aa4729a04a8f8e41a11b5a", - "4107618f389d48359082d1b9b55d0ef9" - ] - }, - "id": "9ea9431a-9ea4-4312-8869-af4c8c4733a4", - "outputId": "061449fa-76e8-48c2-dbc3-66800d039674" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pytorch_lightning.utilities.rank_zero:GPU available: False, used: False\n", - "INFO:pytorch_lightning.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n", - "INFO:pytorch_lightning.utilities.rank_zero:HPU available: False, using: 0 HPUs\n", - "INFO:pytorch_lightning.callbacks.model_summary:\n", - " | Name | Type | Params | Mode \n", - "--------------------------------------------------------\n", - "0 | train_conditions | ModuleList | 5.3 K | train\n", - "1 | val_conditions | ModuleList | 0 | train\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", - "13 Modules in train mode\n", - "0 Modules in eval mode\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e9e9c3f6752640deb4d7f2791a8a329e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: | | 0/? [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = tp.utils.plot(model=model, plot_function=lambda u : u, point_sampler=plot_sampler, label='Learned solution')\n", - "# plot also groundtruth\n", - "sampling_points = np.linspace(0, 2, 100)\n", - "plt.plot(sampling_points, 2*np.exp(sampling_points), label=f'Groundtruth $u(t) = u_0e^t$')\n", - "fig.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "9840aad9", - "metadata": { - "id": "9840aad9" - }, - "outputs": [], - "source": [] + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "1ef6d147-2dd4-4547-9fb6-79b3758d7350", + "metadata": { + "id": "1ef6d147-2dd4-4547-9fb6-79b3758d7350" + }, + "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": "bTGz6NV4_Jzb", + "metadata": { + "id": "bTGz6NV4_Jzb" + }, + "source": [ + "# Physics Informed Neural Networks (PINNs) in TorchPhysics\n", + "In this tutorial we present a first basic example of solving a simple ODE with an initial condition 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 consider the simple ODE:\n", + "$$\n", + "\\begin{cases}\n", + "\\frac{\\partial}{\\partial t} u(t) &= u(t) &&\\text{ on the interval } (0, 2), \\\\\n", + "u(t) &= u_0 &&\\text{ for } t\\in \\{ 0\\}.\n", + "\\end{cases}\n", + "$$\n", + "In the following we want to learn the solution function $u(t) = u_0 e^t$, where we set the initial value to $u_0=2$." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d6b5fdd2-67c1-4f7e-a185-9d515fb9f3f8", + "metadata": { + "id": "d6b5fdd2-67c1-4f7e-a185-9d515fb9f3f8" + }, + "outputs": [], + "source": [ + "u_0 = 2 # initial value" + ] + }, + { + "cell_type": "markdown", + "id": "8da6279e-83c2-41ed-a56b-453b21f05d11", + "metadata": { + "id": "8da6279e-83c2-41ed-a56b-453b21f05d11" + }, + "source": [ + "## Recall PINNs\n", + "The goal is to find a neural network $u_\\theta:[0, 2]\\to \\mathbb{R}$, which approximately satisfies the two conditions of the ODE problem above, where $\\theta$ are the trainable parameters of the neural network.\n", + "Let us shortly recall the main idea behind PINNs.\n", + "\n", + "The residuals are denoted by\n", + "$$\n", + "\\begin{align}\n", + "&\\text{1) Residual of the ODE condition: } &&R_1(u, t) := \\frac{\\partial^2}{\\partial t^2} u(t) - u(t) &&&\\text{ for } t\\in (0,2),\\\\\n", + "&\\text{2) Residual of the initial condition: } &&R_2(u, t) := u(t) - u_0 &&& \\text{ for } t\\in \\{0\\}.\n", + "\\end{align}\n", + "$$\n", + "Continuing with the PINN approach, points are sampled in the domains corresponding to each condition. In our example:\n", + "$$\n", + "\\begin{align}\n", + "&\\text{1) } &&\\big(t_i^{(1)} \\big)_i &&&\\in (0, 2),\\\\\n", + "&\\text{2) } &&\\big(t_j^{(2)} \\big)_j &&&\\in \\{0\\}.\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, t_i^{(1)}) \\big \\vert^2 + \\sum_j \\big\\vert R_2(u_\\theta, t_j^{(2)}) \\big \\vert^2,\n", + "\\end{align}\n", + "$$\n", + "that is, the residuals are minimized with respect to the $l_2$-norm." + ] + }, + { + "cell_type": "markdown", + "id": "8f0db4a0-cace-4d21-845f-f34680880d7d", + "metadata": { + "id": "8f0db4a0-cace-4d21-845f-f34680880d7d" + }, + "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://boschresearch.github.io/torchphysics/tutorial/tutorial_start.html) or [examples](https://boschresearch.github.io/torchphysics/examples.html)." + ] + }, + { + "cell_type": "markdown", + "id": "e8fe0433-82b7-4093-8f6f-8adf7e46ff5b", + "metadata": { + "id": "e8fe0433-82b7-4093-8f6f-8adf7e46ff5b" + }, + "source": [ + "### Step 1: Specify spaces and domains\n", + "The domain $I=(0, 2)$ is a subset of the space $\\mathbb{R}$, whereas the range space of the solution function $u$ is $\\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. We need an interval domain, which is an open interval by default. For creating complexer domains please have a look at the [domain-tutorial](https://boschresearch.github.io/torchphysics/tutorial/tutorial_domain_basics.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6af0dba0-d481-4566-a8b7-244098eee713", + "metadata": { + "id": "6af0dba0-d481-4566-a8b7-244098eee713" + }, + "outputs": [], + "source": [ + "# Input and output spaces\n", + "T = tp.spaces.R1('t')\n", + "U = tp.spaces.R1('u')\n", + "\n", + "# Domain\n", + "I = tp.domains.Interval(space=T, lower_bound=0, upper_bound=2)" + ] + }, + { + "cell_type": "markdown", + "id": "a1676bc3-8dab-4ce4-84ff-f8fc29e8b829", + "metadata": { + "id": "a1676bc3-8dab-4ce4-84ff-f8fc29e8b829" + }, + "source": [ + "### Step 2: Define point samplers for different subsets of [0, 2]\n", + "As mentioned in the PINN recall, it will be necessary to sample points in different subsets of the full domain $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://boschresearch.github.io/torchphysics/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", + "The ODE condition 1) should hold for points in the domain $I=(0, 2)$. We have defined this domain already in Step 1, so that we can define a point sampler:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d020f7f4-c286-466f-928d-1f80ee64c53f", + "metadata": { + "id": "d020f7f4-c286-466f-928d-1f80ee64c53f" + }, + "outputs": [], + "source": [ + "sampler_ode_condition = tp.samplers.RandomUniformSampler(domain=I, n_points=150)" + ] + }, + { + "cell_type": "markdown", + "id": "c9f72b70-0e87-466f-a7c0-0e1f194745cc", + "metadata": { + "id": "c9f72b70-0e87-466f-a7c0-0e1f194745cc" + }, + "source": [ + "Next, let us define samplers for the initial condition. This condition should hold on the domain $\\{0\\}$, which is the left boundary of the interval $I=(0,2)$. All tp.domains.Interval objects have the attribute \"boundary_left\", an instance of TorchPhysics BoundaryDomain class, a subclass of the Domain class. This allows to construct a sampler for this initial condition." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e780f5fa-5ebf-4731-8568-77116ea039f6", + "metadata": { + "id": "e780f5fa-5ebf-4731-8568-77116ea039f6" + }, + "outputs": [], + "source": [ + "domain_initial_condition = I.boundary_left\n", + "sampler_initial_condition = tp.samplers.RandomUniformSampler(domain_initial_condition, 50)" + ] + }, + { + "cell_type": "markdown", + "id": "7750bf6b-30ec-4ca9-8f37-9699439d0d22", + "metadata": { + "id": "7750bf6b-30ec-4ca9-8f37-9699439d0d22" + }, + "source": [ + "For more detailed information on the functionality of TorchPysics samplers, please have a look at the further [tutorials](https://torchphysics.de/tutorial), [examples](https://boschresearch.github.io/torchphysics/examples.html) or the in-depth [sampler-tutorial](https://boschresearch.github.io/torchphysics/tutorial/sampler_tutorial.html)." + ] + }, + { + "cell_type": "markdown", + "id": "6b1b87f9-b6d6-44ec-8fb5-833ab466d89b", + "metadata": { + "id": "6b1b87f9-b6d6-44ec-8fb5-833ab466d89b" + }, + "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$ and $R_2$ vanish.\n", + "\n", + "Let us have a look at $R_1$, the residual for the ODE condition, the way it is defined in the PINNs recall above. The inputs of $R_1$ are the coordinate $t\\in(0,2)$, but also $u_\\theta$, which is itself a function of $t$. In TorchPhysics, the evaluation of the network $u_\\theta$ at $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 tuples $(u, t)$, where $u:=u_\\theta(t)$.\n", + "\n", + "More precisely, $u$ will be a torch.tensor of shape (n_points, 1) and $t$ of shape (n_points, 1), where n_points is the number of triples $(u,t)$ for which the residual should be computed.\n", + "\n", + "For the residual $R_1$ it is required to compute the first derivative (gradient) of $u$ with respect to $t$. This differential operator, among others - see the [utils-tutorial](https://boschresearch.github.io/torchphysics/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": 13, + "id": "c29f3f92-d613-470f-ab74-9369e071ea04", + "metadata": { + "id": "c29f3f92-d613-470f-ab74-9369e071ea04" + }, + "outputs": [], + "source": [ + "def residual_ode_condition(u, t):\n", + " return u - tp.utils.grad(u, t)" + ] + }, + { + "cell_type": "markdown", + "id": "e444a2e5-6fc6-4124-894c-1ba987153241", + "metadata": { + "id": "e444a2e5-6fc6-4124-894c-1ba987153241" + }, + "source": [ + "For the computation of the residual $R_2$ of the initial condition, the coordinate $t\\in \\{0\\}$ is not required, since $u$ is already the evaluation of the network at these sampling points. Therefore, we can conveniently omit them as input parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "65954de9-4c80-4d2a-be6e-0cd16ab82596", + "metadata": { + "id": "65954de9-4c80-4d2a-be6e-0cd16ab82596" + }, + "outputs": [], + "source": [ + "def residual_initial_condition(u):\n", + " return u - u_0" + ] + }, + { + "cell_type": "markdown", + "id": "0cc89ada-310b-4a84-bcc0-77baa7afca2c", + "metadata": { + "id": "0cc89ada-310b-4a84-bcc0-77baa7afca2c" + }, + "source": [ + "### Step 4: Define Neural Network\n", + "At this point, let us define the model $u_\\theta:[0,2]\\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 the [model-tutorial](https://boschresearch.github.io/torchphysics/tutorial/model_creation.html).\n", + "There are also a bunch of predefined neural networks or single layers available. In this tutorial we consider a very simple neural network, a FNO consisting of three hidden layers with $50, 50$ and $50$ neurons, respectively.:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "bdef3d80-90e6-47aa-95ce-6d735fd03f36", + "metadata": { + "id": "bdef3d80-90e6-47aa-95ce-6d735fd03f36" + }, + "outputs": [], + "source": [ + "model = tp.models.FCN(input_space=T, output_space=U, hidden = (50,50,50))" + ] + }, + { + "cell_type": "markdown", + "id": "17e3f8ab-bd6c-4f4f-94a6-030930458c0c", + "metadata": { + "id": "17e3f8ab-bd6c-4f4f-94a6-030930458c0c" + }, + "source": [ + "### Step 5: Create TorchPhysics Conditions\n", + "Let us sum up what we have done so far: For the ODE and initial condition, 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://boschresearch.github.io/torchphysics/tutorial/condition_tutorial.html) for further information." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "008c09a7-81f8-41b5-8c10-3892812740ad", + "metadata": { + "id": "008c09a7-81f8-41b5-8c10-3892812740ad" + }, + "outputs": [], + "source": [ + "ode_condition = tp.conditions.PINNCondition(module =model,\n", + " sampler =sampler_ode_condition,\n", + " residual_fn=residual_ode_condition)\n", + "\n", + "initial_condition = tp.conditions.PINNCondition(module =model,\n", + " sampler =sampler_initial_condition,\n", + " residual_fn=residual_initial_condition)" + ] + }, + { + "cell_type": "markdown", + "id": "5cd77316-3c78-4bf1-b639-9ccb7070af2d", + "metadata": { + "id": "5cd77316-3c78-4bf1-b639-9ccb7070af2d" + }, + "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 ode_condition at points $(t_i)_i$ in $I=(0,2)$ will return\n", + "$$\n", + "\\begin{align}\n", + "\\sum_i \\big \\vert R_1(u_\\theta, t_i) \\big \\vert^2,\n", + "\\end{align}\n", + "$$\n", + "where $R_1$ is the residual function for the ODE 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": { + "id": "2e0fad4c-2cfd-4c10-8e2f-0a3702a2eeac" + }, + "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/boschresearch/torchphysics/blob/main/examples/pinn/interface-jump.ipynb) to train different networks for different conditions of the PDE problem." + ] + }, + { + "cell_type": "markdown", + "id": "31d80c43-5879-401c-8212-0e4a5fd6514c", + "metadata": { + "id": "31d80c43-5879-401c-8212-0e4a5fd6514c" + }, + "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": 17, + "id": "bb76e892-bf53-4a01-adc5-74dddb770525", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bb76e892-bf53-4a01-adc5-74dddb770525", + "outputId": "ca750735-3e1e-4fcc-ca59-e020d6131434" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GPU available: True\n" + ] + } + ], + "source": [ + "import pytorch_lightning as pl\n", + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\" if torch.cuda.is_available() else \"0\"\n", + "\n", + "print (\"GPU available: \" + str(torch.cuda.is_available()))" + ] + }, + { + "cell_type": "markdown", + "id": "1639cf38-835b-4571-b0c5-7ef0d130c2df", + "metadata": { + "id": "1639cf38-835b-4571-b0c5-7ef0d130c2df" + }, + "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": 18, + "id": "ea27b608-e319-4fac-85c1-5984f2d043c6", + "metadata": { + "id": "ea27b608-e319-4fac-85c1-5984f2d043c6" + }, + "outputs": [], + "source": [ + "training_conditions = [ode_condition, initial_condition]" + ] + }, + { + "cell_type": "markdown", + "id": "e024913e-e10e-4387-b390-165e77c8524b", + "metadata": { + "id": "e024913e-e10e-4387-b390-165e77c8524b" + }, + "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." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "b1848d26-ea33-400c-84be-2291429e8065", + "metadata": { + "id": "b1848d26-ea33-400c-84be-2291429e8065" + }, + "outputs": [], + "source": [ + "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=0.001)" + ] + }, + { + "cell_type": "markdown", + "id": "efcd0c8c-1ef2-45a0-bf00-de88201f3d03", + "metadata": { + "id": "efcd0c8c-1ef2-45a0-bf00-de88201f3d03" + }, + "source": [ + "Finally, we are able to create the Solver object, a Pytorch Lightning Module." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ea2cb3f-087c-4e03-aeb0-40318f556062", + "metadata": { + "id": "4ea2cb3f-087c-4e03-aeb0-40318f556062" + }, + "outputs": [], + "source": [ + "solver = tp.solver.Solver(train_conditions=training_conditions, val_conditions=[initial_condition],optimizer_setting=optim)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "295317b2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'train/pinncondition': tensor(1.5838e-05),\n", + " 'train/loss': tensor(0.0001),\n", + " 'val/pinncondition': tensor(1.5381e-05)}" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" } - ], - "metadata": { + ], + "source": [ + "trainer.callback_metrics" + ] + }, + { + "cell_type": "markdown", + "id": "53dec402-5dd2-40f9-a405-5170d0cfcbd7", + "metadata": { + "id": "53dec402-5dd2-40f9-a405-5170d0cfcbd7" + }, + "source": [ + "Now, as usual, the training is done with a Pytorch Lightning Trainer object and its fit() method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9ea9431a-9ea4-4312-8869-af4c8c4733a4", + "metadata": { "colab": { - "provenance": [], - "toc_visible": true - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.19" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "099fcd830e64454093b45f9ec3a9cc4a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_cd0ca01f50124df0ac6c951d6d31ab85", - "max": 1000, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_58dbae958d11454e88b91efedb750d65", - "value": 1000 - } - }, - "1b5ba0b918de430da29cfca2f2a7afbf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "3b582cb05b834f60b6311fdbde240407": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_5f06b3f84db348c8b32ee48089e01f01", - "placeholder": "​", - "style": "IPY_MODEL_f3ebae78a3674c6c93fd64b3ed3e7542", - "value": "Epoch 0: 100%" - } - }, - "4107618f389d48359082d1b9b55d0ef9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "4250369b168442daa28a85e459fd788e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "58dbae958d11454e88b91efedb750d65": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "5f06b3f84db348c8b32ee48089e01f01": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6553e0de7efa42728366a465d83a948f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_1b5ba0b918de430da29cfca2f2a7afbf", - "placeholder": "​", - "style": "IPY_MODEL_b6390043fdd048849050dc7526dbe7df", - "value": "Validation DataLoader 0: 100%" - } - }, - "79b83887a2bb4248ae991970d6a274b1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_b321cd7f2e454f21a4e1ea33c7ff4ce3", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_4250369b168442daa28a85e459fd788e", - "value": 1 - } - }, - "8ed5e770686f4cb78a0bc85a39ae4157": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "8f703e85f7aa4729a04a8f8e41a11b5a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "96e31c05ff4c4a87aef91967cf4292e1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "b321cd7f2e454f21a4e1ea33c7ff4ce3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b6390043fdd048849050dc7526dbe7df": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "c733319a53f94defb4948ab02d05837c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "cd0ca01f50124df0ac6c951d6d31ab85": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d8e62d4fa51c4cedbff580f154dd3a17": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_8ed5e770686f4cb78a0bc85a39ae4157", - "placeholder": "​", - "style": "IPY_MODEL_c733319a53f94defb4948ab02d05837c", - "value": " 1000/1000 [00:37<00:00, 26.83it/s, train/loss=0.000856]" - } - }, - "e0ba190eae4e4d5192b5e1ce501af014": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_8f703e85f7aa4729a04a8f8e41a11b5a", - "placeholder": "​", - "style": "IPY_MODEL_4107618f389d48359082d1b9b55d0ef9", - "value": " 1/1 [00:00<00:00, 259.10it/s]" - } - }, - "e9e9c3f6752640deb4d7f2791a8a329e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3b582cb05b834f60b6311fdbde240407", - "IPY_MODEL_099fcd830e64454093b45f9ec3a9cc4a", - "IPY_MODEL_d8e62d4fa51c4cedbff580f154dd3a17" - ], - "layout": "IPY_MODEL_fd6826c5f1a54e93ae8b6ab4d3d6e421" - } - }, - "f3ebae78a3674c6c93fd64b3ed3e7542": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "fcd564594edd4d9582d3a4b3e212a3f2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_6553e0de7efa42728366a465d83a948f", - "IPY_MODEL_79b83887a2bb4248ae991970d6a274b1", - "IPY_MODEL_e0ba190eae4e4d5192b5e1ce501af014" - ], - "layout": "IPY_MODEL_96e31c05ff4c4a87aef91967cf4292e1" - } - }, - "fd6826c5f1a54e93ae8b6ab4d3d6e421": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "100%" - } - } - } + "base_uri": "https://localhost:8080/", + "height": 347, + "referenced_widgets": [ + "e9e9c3f6752640deb4d7f2791a8a329e", + "3b582cb05b834f60b6311fdbde240407", + "099fcd830e64454093b45f9ec3a9cc4a", + "d8e62d4fa51c4cedbff580f154dd3a17", + "fd6826c5f1a54e93ae8b6ab4d3d6e421", + "5f06b3f84db348c8b32ee48089e01f01", + "f3ebae78a3674c6c93fd64b3ed3e7542", + "cd0ca01f50124df0ac6c951d6d31ab85", + "58dbae958d11454e88b91efedb750d65", + "8ed5e770686f4cb78a0bc85a39ae4157", + "c733319a53f94defb4948ab02d05837c", + "fcd564594edd4d9582d3a4b3e212a3f2", + "6553e0de7efa42728366a465d83a948f", + "79b83887a2bb4248ae991970d6a274b1", + "e0ba190eae4e4d5192b5e1ce501af014", + "96e31c05ff4c4a87aef91967cf4292e1", + "1b5ba0b918de430da29cfca2f2a7afbf", + "b6390043fdd048849050dc7526dbe7df", + "b321cd7f2e454f21a4e1ea33c7ff4ce3", + "4250369b168442daa28a85e459fd788e", + "8f703e85f7aa4729a04a8f8e41a11b5a", + "4107618f389d48359082d1b9b55d0ef9" + ] + }, + "id": "9ea9431a-9ea4-4312-8869-af4c8c4733a4", + "outputId": "061449fa-76e8-48c2-dbc3-66800d039674" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "HPU available: False, using: 0 HPUs\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [1]\n", + "\n", + " | Name | Type | Params | Mode \n", + "--------------------------------------------------------\n", + "0 | train_conditions | ModuleList | 5.3 K | train\n", + "1 | val_conditions | ModuleList | 5.3 K | train\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", + "13 Modules in train mode\n", + "0 Modules in eval mode\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7396c4fc61f246bf83bdf63771b6b6cd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" } + ], + "source": [ + "fig = tp.utils.plot(model=model, plot_function=lambda u : u, point_sampler=plot_sampler, label='Learned solution')\n", + "# plot also groundtruth\n", + "sampling_points = np.linspace(0, 2, 100)\n", + "plt.plot(sampling_points, 2*np.exp(sampling_points), label=f'Groundtruth $u(t) = u_0e^t$')\n", + "fig.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "9840aad9", + "metadata": { + "id": "9840aad9" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "torchphysics", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 5 + "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.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 } diff --git a/src/torchphysics/models/FNO.py b/src/torchphysics/models/FNO.py index c92c49e9..dd2592df 100644 --- a/src/torchphysics/models/FNO.py +++ b/src/torchphysics/models/FNO.py @@ -4,6 +4,14 @@ from ..problem.spaces import Points +class _Permute(nn.Module): + def __init__(self, permute_dims): + super().__init__() + self.permute_dims = permute_dims + + def forward(self, x): + return x.permute(self.permute_dims) + class _FourierLayer(nn.Module): """Implements a single Fourier layer of the FNO. For the parameter description see @@ -26,9 +34,9 @@ def __init__(self, channels, mode_num, self.fourier_dims = list(range(1, self.data_dim+1)) # Learnable parameters - self.fourier_kernel = torch.nn.Parameter( + self.fourier_kernel = nn.Parameter( torch.empty((*self.mode_num, self.channels), dtype=torch.cfloat)) - torch.nn.init.xavier_normal_(self.fourier_kernel, gain=xavier_gain) + nn.init.xavier_normal_(self.fourier_kernel, gain=xavier_gain) self.linear_connection : bool = linear_connection if self.linear_connection: @@ -38,10 +46,15 @@ def __init__(self, channels, mode_num, if space_res: self.use_bn = True if self.data_dim == 1: - self.bn = torch.nn.BatchNorm1d(space_res) + self.bn = nn.BatchNorm1d(space_res) else: - raise NotImplementedError(f"Dimension {self.data_dim} currently not \ - supported for batch normalization") + # for higher dimensions we need to permute the dimensions, since + # the layer norm only operates on the last dimensions. + self.bn = nn.Sequential( + _Permute([0, self.data_dim+1, *range(1, self.data_dim+1)]), + nn.LayerNorm(space_res), + _Permute([0, *range(2, self.data_dim+2), 1]) + ) def forward(self, points): @@ -55,7 +68,7 @@ def forward(self, points): padding = torch.zeros(2*self.data_dim + 2, device=points.device, dtype=torch.int32) padding[3::2] = torch.flip((self.mode_num - original_fft_shape), dims=(0,)) - fft = torch.nn.functional.pad(fft, padding.tolist()) + fft = nn.functional.pad(fft, padding.tolist()) fft *= self.fourier_kernel @@ -121,12 +134,12 @@ class FNO(Model): For the weight initialization a Xavier/Glorot algorithm will be used. The gain can be specified over this value. Default is 5/3. - space_resolution : int or None + space_resolution : int, list, tuple or None The resolution of the space grid used for training. This value is optional. If specified, a batch normalization over the space dimension will be applied in each Fourier layer. This leads to smoother solutions and better local approximations. But (currently) removes the super resolution property of the - FNO. This is currently only possible for 1D space dimensions. + FNO. Notes ----- @@ -203,7 +216,8 @@ def _extend_data(self, fourier_layers, skip_connections): def forward(self, points): - points = self._fix_points_order(points) + if not torch.is_tensor(points): + points = self._fix_points_order(points) points_up_sampled = self.channel_up_sampling(points) fourier_points = self.fourier_sequential(points_up_sampled) output = self.channel_down_sampling(fourier_points) diff --git a/src/torchphysics/models/PCANN.py b/src/torchphysics/models/PCANN.py new file mode 100644 index 00000000..d1f28bbf --- /dev/null +++ b/src/torchphysics/models/PCANN.py @@ -0,0 +1,234 @@ +import torch + +from .model import Model +from .fcn import _construct_FC_layers +from ..problem.domains.functionsets import DiscreteFunctionSet +from ..problem.spaces.points import Points + +class PCANN(Model): + """A general neural network model that uses PCA to reduce the + dimensionality of the input and output spaces and then only learns + a mapping of the principal components. + Follows the idea presented in [1]. + + Parameters + ---------- + input_space, output_space : Space + The input and output space of the model. + pca_in, pca_out : tuple + The principal component decomposition of the input and output data. + Should be of the form (U, S, V) where U contains the left eigen vectors, + S the eigen values of the covariance matrix and V the right eigen + vectors of input and output data respectively. + See also https://pytorch.org/docs/stable/generated/torch.pca_lowrank.html + for the format which is expected. + output_shape : tuple + The shape of the output data. + This is needed to reshape the output after the neural network and PCA + have been applied. + mean_in, mean_out : tensor + The mean of the input and output data. + This is used to normalize the data before applying the PCA. + std_in, std_out : tensor + The standard deviation of the input and output data. + This is used to normalize the data before applying the PCA. + + Notes + ----- + The default implemwentation flatten the input and output data along all + dimensions except the first one. + + .. [1] Kaushik Bhattacharya et al., "Model Reduction And Neural Networks For + Parametric PDEs", 2021 + """ + + def __init__(self, input_space, output_space, pca_in, pca_out, output_shape, + mean_in=torch.tensor(0), mean_out=torch.tensor(0), + std_in=torch.tensor(1), std_out=torch.tensor(1)): + super().__init__(input_space, output_space) + + self.register_buffer("eigenvectors_in", pca_in[2]) + self.register_buffer("eigenvectors_out", pca_out[2]) + + ev_values_in = torch.sqrt(pca_in[1]**2 / (len(pca_in[0]) - 1)) + self.register_buffer("eigenvalues_in", ev_values_in) + ev_values_out = torch.sqrt(pca_out[1]**2 / (len(pca_out[0]) - 1)) + self.register_buffer("eigenvalues_out", ev_values_out) + + self.register_buffer("mean_in", mean_in) + self.register_buffer("mean_out", mean_out) + self.register_buffer("std_in", std_in) + self.register_buffer("std_out", std_out) + + self.output_shape = [-1, *output_shape, self.output_space.dim] + + + @classmethod + def from_fn_set(cls, + input_fn_set : DiscreteFunctionSet, + output_fn_set : DiscreteFunctionSet): + """Construct a PCANN model from two **discrete** function sets. + + Parameters + ---------- + input_fn_set, output_fn_set : DiscreteFunctionSet + The function sets containing the input and expected output + data. + """ + return cls(input_fn_set.function_space.output_space, + output_fn_set.function_space.output_space, + output_shape = output_fn_set.data_shape, + pca_in = input_fn_set.principal_components, + pca_out = output_fn_set.principal_components, + mean_in = input_fn_set.mean, + mean_out = output_fn_set.mean, + std_in = input_fn_set.std, + std_out = output_fn_set.std) + + + def apply_network(self, pc_input): + """Apply the neural network to the principal components. + + Parameters + ---------- + pc_input : tensor + The principal components of the input data. + + Returns + ------- + tensor + The predicted principal components of the output data. + + Note + ---- + This function should be implemented in the sub classes. + """ + raise NotImplementedError("PCANN can not be used directly! Use one of the sub classes.") + + + def forward(self, points): + if not torch.is_tensor(points): + points = self._fix_points_order(points).as_tensor + # normalize inputs + points = (points - self.mean_in) / self.std_in + # apply pca + points = torch.flatten(points, start_dim=1) + pc_in = points @ self.eigenvectors_in + pc_in /= self.eigenvalues_in + # Then evaluate neural network + pc_out = self.apply_network(pc_input=pc_in) + # "inverse" pca + pc_out *= self.eigenvalues_out + points_out = pc_out @ self.eigenvectors_out.T + points_out = points_out.reshape(self.output_shape) + # "inverse" normalization + points_out = points_out * self.std_out + self.mean_out + # reshape and transform to points + return Points(points_out, self.output_space) + + +class PCANN_FC(PCANN): + """ A PCANN model that uses a fully connected neural network to learn the + mapping between the principal components of the input and output data. + + Parameters + ---------- + Parameters + ---------- + input_space, output_space : Space + The input and output space of the model. + pca_in, pca_out : tuple + The principal component decomposition of the input and output data. + Should be of the form (U, S, V) where U contains the left eigen vectors, + S the eigen values of the covariance matrix and V the right eigen + vectors of input and output data respectively. + See also https://pytorch.org/docs/stable/generated/torch.pca_lowrank.html + for the format which is expected. + output_shape : tuple + The shape of the output data. + This is needed to reshape the output after the neural network and PCA + have been applied. + 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 + of hidden layers, while the i-th entry will determine the number + of neurons of each layer. + E.g hidden = (10, 5) -> 2 layers, with 10 and 5 neurons. + activations : torch.nn or list, optional + The activation functions of this network. If a single function is passed + as an input, will use this function for each layer. + If a list is used, will use the i-th entry for i-th layer. + Deafult is nn.Tanh(). + xavier_gains : float or list, optional + For the weight initialization a Xavier/Glorot algorithm will be used. + The gain can be specified over this value. + Default is 5/3. + mean_in, mean_out : tensor + The mean of the input and output data. + This is used to normalize the data before applying the PCA. + std_in, std_out : tensor + The standard deviation of the input and output data. + This is used to normalize the data before applying the PCA. + """ + def __init__(self, input_space, output_space, pca_in, pca_out, output_shape, + hidden=(20, 20, 20), activations=torch.nn.Tanh(),xavier_gains=5/3, + mean_in=torch.tensor(0), mean_out=torch.tensor(0), + std_in=torch.tensor(1), std_out=torch.tensor(1)): + super().__init__(input_space, output_space, pca_in, pca_out, output_shape, + mean_in, mean_out, std_in, std_out) + + layers = _construct_FC_layers( + hidden=hidden, + input_dim=len(self.eigenvalues_in), + output_dim=len(self.eigenvalues_out), + activations=activations, + xavier_gains=xavier_gains, + ) + + self.sequential = torch.nn.Sequential(*layers) + + @classmethod + def from_fn_set(cls, + input_fn_set : DiscreteFunctionSet, + output_fn_set : DiscreteFunctionSet, + hidden=(20, 20, 20), + activations=torch.nn.Tanh(), + xavier_gains=5/3): + """Construct a PCANN_FC model from two **discrete** function sets. + + Parameters + ---------- + input_fn_set, output_fn_set : DiscreteFunctionSet + The function sets containing the input and expected output + data. + 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 + of hidden layers, while the i-th entry will determine the number + of neurons of each layer. + E.g. hidden = (10, 5) -> 2 layers, with 10 and 5 neurons. + activations : torch.nn or list, optional + The activation functions of this network. If a single function is passed + as an input, will use this function for each layer. + If a list is used, will use the i-th entry for i-th layer. + Deafult is nn.Tanh(). + xavier_gains : float or list, optional + For the weight initialization a Xavier/Glorot algorithm will be used. + The gain can be specified over this value. + Default is 5/3. + """ + return cls(input_fn_set.function_space.output_space, + output_fn_set.function_space.output_space, + output_shape = output_fn_set.data_shape, + pca_in = input_fn_set.principal_components, + pca_out = output_fn_set.principal_components, + hidden=hidden, activations=activations, + xavier_gains=xavier_gains, + mean_in = input_fn_set.mean, + mean_out = output_fn_set.mean, + std_in = input_fn_set.std, + std_out = output_fn_set.std) + + + def apply_network(self, pc_input): + return self.sequential(pc_input) \ No newline at end of file diff --git a/src/torchphysics/models/__init__.py b/src/torchphysics/models/__init__.py index 1b833a9c..891c7da5 100644 --- a/src/torchphysics/models/__init__.py +++ b/src/torchphysics/models/__init__.py @@ -11,7 +11,8 @@ """ from .parameter import Parameter -from .model import Model, NormalizationLayer, AdaptiveWeightLayer, Sequential, Parallel +from .model import (Model, NormalizationLayer, AdaptiveWeightLayer, + Sequential, Parallel, HardConstraint) from .fcn import FCN, Harmonic_FCN, Polynomial_FCN from .deepritz import DeepRitzNet from .qres import QRES @@ -19,9 +20,12 @@ # DeepONet: from .deeponet.deeponet import DeepONet -from .deeponet.branchnets import BranchNet, FCBranchNet, ConvBranchNet1D +from .deeponet.branchnets import BranchNet, FCBranchNet, ConvBranchNet from .deeponet.trunknets import TrunkNet, FCTrunkNet from .deeponet.layers import TrunkLinear # FNO: -from .FNO import FNO, _FourierLayer \ No newline at end of file +from .FNO import FNO, _FourierLayer + +# PCA: +from .PCANN import PCANN, PCANN_FC \ No newline at end of file diff --git a/src/torchphysics/models/deeponet/branchnets.py b/src/torchphysics/models/deeponet/branchnets.py index c67efa2f..2d66bab8 100644 --- a/src/torchphysics/models/deeponet/branchnets.py +++ b/src/torchphysics/models/deeponet/branchnets.py @@ -16,33 +16,43 @@ class BranchNet(Model): ---------- function_space : Space The space of functions that can be put in this network. - discretization_sampler : torchphysics.sampler - A sampler that will create the points at which the input functions should + grid : torchphysics.spaces.Points + 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! + The number of input neurons will be equal to the number of grid points. """ - def __init__(self, function_space, discretization_sampler): + def __init__(self, function_space, grid): super().__init__(function_space, output_space=None) + # Transform to points to have unified checks + if torch.is_tensor(grid): + grid = Points(grid, function_space.input_space) + self.output_neurons = 0 - self.discretization_sampler = discretization_sampler - self.input_dim = ( - len(self.discretization_sampler) * function_space.output_space.dim - ) + self.register_buffer("grid_buffer", grid.as_tensor) self.current_out = torch.empty(0) + def __getattr__(self, name): + if name == "grid": + return object.__getattribute__(self, "grid") + # Call parent __getattr__ for other cases + return super().__getattr__(name) + + @property + def grid(self): + return Points(self.grid_buffer, self.input_space.input_space) + 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. + The space to 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 + output space, so each dimension will have the same amount of intermediate neurons. """ self.output_neurons = output_neurons @@ -50,7 +60,7 @@ def finalize(self, output_space, output_neurons): def _reshape_multidimensional_output(self, output): return output.reshape( - -1, self.output_space.dim, int(self.output_neurons / self.output_space.dim) + *output.shape[:-1], self.output_space.dim, self.output_neurons ) @abc.abstractmethod @@ -72,13 +82,6 @@ def forward(self, discrete_function_batch, device="cpu"): """ raise NotImplementedError - def _discretize_function_set(self, function_set, device="cpu"): - """Internal discretization of the training set.""" - input_points = self.discretization_sampler.sample_points(device=device) - # self.input_points = input_points - fn_out = function_set.create_function_batch(input_points) - return fn_out - def fix_input(self, function, device="cpu"): """Fixes the branch net for a given function. The branch net will be evaluated for the given function and the output saved in ``current_out``. @@ -97,11 +100,14 @@ def fix_input(self, function, device="cpu"): ``.fix_input`` again with a new function. """ if isinstance(function, FunctionSet): - function.sample_params(device=device) - discrete_fn = self._discretize_function_set(function, device=device) + function.create_functions(device=device) + index = torch.arange(function.function_set_size) + fns = function.get_function(index) + input_points = self.grid.to(device) + discrete_fn = fns(input_points) elif callable(function): function = UserFunction(function) - discrete_points = self.discretization_sampler.sample_points(device=device) + discrete_points = self.grid.to(device) discrete_fn = function(discrete_points) discrete_fn = discrete_fn.unsqueeze(0) # add batch dimension discrete_fn = Points(discrete_fn, self.input_space.output_space) @@ -128,17 +134,17 @@ def fix_input(self, function, device="cpu"): class FCBranchNet(BranchNet): - """A neural network that can be used inside a DeepONet-model. + """A fully connected neural network as a branch net inside a DeepONet-model. Parameters ---------- function_space : Space The space of functions that can be put in this network. - discretization_sampler : torchphysics.sampler - A sampler that will create the points at which the input functions should + grid : torchphysics.spaces.Points + 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! + The number of input neurons will be equal to the number of grid points + times the function space dimension. 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 @@ -155,22 +161,24 @@ class FCBranchNet(BranchNet): def __init__( self, function_space, - discretization_sampler, + grid, hidden=(20, 20, 20), activations=nn.Tanh(), xavier_gains=5 / 3, ): - super().__init__(function_space, discretization_sampler) + super().__init__(function_space, grid) self.hidden = hidden self.activations = activations self.xavier_gains = xavier_gains + + self.input_neurons = len(self.grid) * self.input_space.output_space.dim 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, + input_dim=self.input_neurons, + output_dim=self.output_neurons*self.output_space.dim, activations=self.activations, xavier_gains=self.xavier_gains, ) @@ -179,14 +187,14 @@ def finalize(self, output_space, output_neurons): def forward(self, discrete_function_batch): discrete_function_batch = discrete_function_batch.as_tensor.reshape( - -1, self.input_dim + -1, self.input_neurons ) self.current_out = self._reshape_multidimensional_output( self.sequential(discrete_function_batch) ) -class ConvBranchNet1D(BranchNet): +class ConvBranchNet(BranchNet): """A branch network that first applies a convolution to the input functions and afterwards linear FC-layers. @@ -194,11 +202,10 @@ class ConvBranchNet1D(BranchNet): ---------- function_space : Space The space of functions that can be put in this network. - discretization_sampler : torchphysics.sampler - A sampler that will create the points at which the input functions should + grid : torchphysics.spaces.Points + The points at which the input functions should be 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! + The number of input neurons will be equal to the number of grid points. convolutional_network : torch.nn.module The user defined convolutional network, that should be applied to the branch input. Inside this network, the input can be transformed arbitrary, @@ -206,10 +213,8 @@ class ConvBranchNet1D(BranchNet): We only expect that the network gets the input in the shape: [batch_dim, function_space.output_space.dim (channels_in), - len(discretization_sampler)] + len(grid)] - You have to make sure, that the number of output dimension is - compatible with the following linear layers. 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 @@ -226,13 +231,13 @@ class ConvBranchNet1D(BranchNet): def __init__( self, function_space, - discretization_sampler, + grid, convolutional_network, hidden=(20, 20, 20), activations=nn.Tanh(), xavier_gains=5 / 3, ): - super().__init__(function_space, discretization_sampler) + super().__init__(function_space, grid) self.conv_net = convolutional_network self.hidden = hidden self.activations = activations @@ -242,32 +247,22 @@ 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, + input_dim=None, + output_dim=self.output_neurons*self.output_space.dim, activations=self.activations, xavier_gains=self.xavier_gains, ) self.sequential = nn.Sequential(*layers) - def _discretize_fn(self, function, device): - # where is this function used? - function = UserFunction(function) - discrete_points = self.discretization_sampler.sample_points(device=device) - discrete_fn = function(discrete_points) - if discrete_fn.shape[0] == self.input_dim: - discrete_fn = discrete_fn.T - return discrete_fn.unsqueeze(-1) - def forward(self, discrete_function_batch): # for convolution we have to change the dimension order of # the input. - # Pytorch conv1D needs: (batch, channels_in, length) - # Generally we have : (batch, length, channels_in), where channels_in + # Pytorch conv need: (batch, channels_in, length_1, length_2, ...) + # Generally we have : (batch, length_1, ..., channels_in), where channels_in # corresponds to the output dimension of our functions and length to the - # number of discretization points. -> switch dim. 1 and 2 + # number of discretization points. -> move dim. -1 to 1 discrete_function_batch = discrete_function_batch.as_tensor - x = self.conv_net(discrete_function_batch.permute(0, 2, 1)) - # for the linear layer transform again and remove the last dimension: - out = self.sequential(x.permute(0, 2, 1).reshape(-1, self.input_dim)) + x = self.conv_net(torch.moveaxis(discrete_function_batch, -1, 1)) + out = self.sequential(x.flatten(start_dim=1)) self.current_out = self._reshape_multidimensional_output(out) diff --git a/src/torchphysics/models/deeponet/deeponet.py b/src/torchphysics/models/deeponet/deeponet.py index a8c97b9a..c26285c8 100644 --- a/src/torchphysics/models/deeponet/deeponet.py +++ b/src/torchphysics/models/deeponet/deeponet.py @@ -61,13 +61,14 @@ def _finalize_trunk_and_branch(self, output_space, output_neurons): self.trunk.finalize(output_space, output_neurons) self.branch.finalize(output_space, output_neurons) - def forward(self, trunk_inputs, branch_inputs=None, device="cpu"): + def forward(self, trunk_inputs=None, branch_inputs=None, device="cpu"): """Apply the network to the given inputs. Parameters ---------- - trunk_inputs : torchphysics.spaces.Points + trunk_inputs : torchphysics.spaces.Points, optional The inputs for the trunk net. + If no input is passed in, the default values from the trunk net are used. branch_inputs : callable, torchphysics.domains.FunctionSet, optional The function(s) for which the branch should be evaluaded. If no input is given, the branch net has to be fixed before hand! @@ -83,20 +84,19 @@ def forward(self, trunk_inputs, branch_inputs=None, device="cpu"): 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: - trunk_out = trunk_out.unsqueeze(0) # shape = [1, trunk_n, dim, neurons] - out = torch.sum(trunk_out * self.branch.current_out.unsqueeze(1), dim=-1) + + view_shape = [1] * (len(trunk_out.shape[:-2]) - 1) # last two axis for output + branch_out = self.branch.current_out.view( + self.branch.current_out.shape[0], *view_shape, + self.branch.output_space.dim, self.branch.output_neurons + ) + + out = torch.sum(trunk_out * branch_out, dim=-1) return Points(out, self.output_space) def _forward_branch(self, function_set, iteration_num=-1, device="cpu"): """Branch evaluation for training.""" - if iteration_num != function_set.current_iteration_num: - function_set.current_iteration_num = iteration_num - function_set.sample_params(device=device) - discrete_fn_batch = self.branch._discretize_function_set( - function_set, device=device - ) - self.branch(discrete_fn_batch) + self.branch.fix_input(function_set, device) def fix_branch_input(self, function, device="cpu"): """Fixes the branch net for a given function. this function will then be used diff --git a/src/torchphysics/models/deeponet/trunknets.py b/src/torchphysics/models/deeponet/trunknets.py index b950ceeb..0b5a2e65 100644 --- a/src/torchphysics/models/deeponet/trunknets.py +++ b/src/torchphysics/models/deeponet/trunknets.py @@ -4,7 +4,7 @@ from ..model import Model from .layers import TrunkLinear from ..fcn import _construct_FC_layers - +from ...problem.spaces.points import Points class TrunkNet(Model): """A neural network that can be used inside a DeepONet-model. @@ -13,6 +13,12 @@ class TrunkNet(Model): ---------- input_space : Space The space of the points that can be put into this model. + default_trunk_input : tp.spaces.Points, torch.tensor + The default input for the trunk net if no other values are specified. + This default is used when the DeepONet only should be evaluated for new + branch inputs, but the trunk input stays fixed. Shape should be of the form + (N_batch, ..., dimension of input space), here ... can be abritrary many dimensions. + If trunk_input_copied=True, N_batch needs to be equal to 1. 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 @@ -21,14 +27,22 @@ class TrunkNet(Model): If for example a dataset with different trunk inputs for each branch function is used, set trunk_input_copied = False. Else this may lead to unexpected behavior. - """ - def __init__(self, input_space, trunk_input_copied=True): + def __init__(self, input_space, default_trunk_input, trunk_input_copied=True): super().__init__(input_space, output_space=None) self.output_neurons = 0 self.trunk_input_copied = trunk_input_copied + if torch.is_tensor(default_trunk_input): + self.default_trunk_input = Points(default_trunk_input, input_space) + elif isinstance(default_trunk_input, Points): + self.default_trunk_input = default_trunk_input + else: + raise ValueError("Provided default input is not supported!") + + self.default_trunk_input = self._fix_points_order(self.default_trunk_input) + 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 @@ -48,15 +62,8 @@ def finalize(self, output_space, 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, - int(self.output_neurons / self.output_space.dim), - ) return output.reshape( - -1, self.output_space.dim, int(self.output_neurons / self.output_space.dim) + *output.shape[:-1], self.output_space.dim, self.output_neurons ) @@ -102,12 +109,13 @@ class FCTrunkNet(TrunkNet): def __init__( self, input_space, + default_trunk_input, hidden=(20, 20, 20), activations=nn.Tanh(), xavier_gains=5 / 3, trunk_input_copied=True, ): - super().__init__(input_space, trunk_input_copied=trunk_input_copied) + super().__init__(input_space, default_trunk_input,trunk_input_copied=trunk_input_copied) self.hidden = hidden self.activations = activations self.xavier_gains = xavier_gains @@ -119,7 +127,7 @@ def finalize(self, output_space, output_neurons): layers = construct_FC_trunk_layers( hidden=self.hidden, input_dim=self.input_space.dim, - output_dim=self.output_neurons, + output_dim=self.output_neurons*self.output_space.dim, activations=self.activations, xavier_gains=self.xavier_gains, ) @@ -127,7 +135,7 @@ def finalize(self, output_space, output_neurons): layers = _construct_FC_layers( hidden=self.hidden, input_dim=self.input_space.dim, - output_dim=self.output_neurons, + output_dim=self.output_neurons*self.output_space.dim, activations=self.activations, xavier_gains=self.xavier_gains, ) @@ -135,5 +143,12 @@ def finalize(self, output_space, output_neurons): self.sequential = nn.Sequential(*layers) def forward(self, points): - points = self._fix_points_order(points) - return self._reshape_multidimensional_output(self.sequential(points.as_tensor)) + if points: + points = self._fix_points_order(points) + return self._reshape_multidimensional_output(self.sequential(points.as_tensor)) + else: + current_device = next(self.sequential[0].parameters()).device + self.default_trunk_input = self.default_trunk_input.to(current_device) + return self._reshape_multidimensional_output( + self.sequential(self.default_trunk_input.as_tensor) + ) diff --git a/src/torchphysics/models/fcn.py b/src/torchphysics/models/fcn.py index f9853d05..6267ce3b 100644 --- a/src/torchphysics/models/fcn.py +++ b/src/torchphysics/models/fcn.py @@ -14,8 +14,11 @@ def _construct_FC_layers(hidden, input_dim, output_dim, activations, xavier_gain xavier_gains = len(hidden) * [xavier_gains] layers = [] - layers.append(nn.Linear(input_dim, hidden[0])) - torch.nn.init.xavier_normal_(layers[-1].weight, gain=xavier_gains[0]) + if input_dim is None: + layers.append(nn.LazyLinear(hidden[0])) + else: + layers.append(nn.Linear(input_dim, hidden[0])) + torch.nn.init.xavier_normal_(layers[-1].weight, gain=xavier_gains[0]) layers.append(activations[0]) for i in range(len(hidden) - 1): layers.append(nn.Linear(hidden[i], hidden[i + 1])) @@ -50,6 +53,9 @@ class FCN(Model): For the weight initialization a Xavier/Glorot algorithm will be used. The gain can be specified over this value. Default is 5/3. + activation_fn_output : torch.nn or None + An additional activation that is applied to the output of the network. + Default is None. """ def __init__( @@ -58,7 +64,8 @@ def __init__( output_space, hidden=(20, 20, 20), activations=nn.Tanh(), - xavier_gains=5 / 3, + xavier_gains=5/3, + activation_fn_output=None, ): super().__init__(input_space, output_space) @@ -70,6 +77,9 @@ def __init__( xavier_gains=xavier_gains, ) + if not activation_fn_output is None: + layers.append(activation_fn_output) + self.sequential = nn.Sequential(*layers) def forward(self, points): diff --git a/src/torchphysics/models/model.py b/src/torchphysics/models/model.py index c081ba56..f55b6945 100644 --- a/src/torchphysics/models/model.py +++ b/src/torchphysics/models/model.py @@ -2,7 +2,7 @@ import torch.nn as nn from ..problem.spaces import Points, Space - +from ..utils.user_fun import UserFunction class Model(nn.Module): """Neural networks that can be trained to fulfill user-defined conditions. @@ -30,6 +30,29 @@ def _fix_points_order(self, points): points = points[..., list(self.input_space.keys())] return points + def save(self, path): + """Save the model parameters/weights to a file. + + Parameters + ---------- + path : str + The path to the file where the model should be saved. + + Notes + ----- + This does not save the model architecture, only the weights. + """ + torch.save(self.state_dict(), path) + + def load(self, path): + """Load the model parameters/weights from a file. + + Parameters + ---------- + path : str + The path to the file where the model should be loaded from. + """ + self.load_state_dict(torch.load(path)) class NormalizationLayer(Model): """ @@ -159,3 +182,36 @@ def __init__(self, n): def forward(self, points): weight = self.grad_reverse(self.weight) return weight * points + + +class HardConstraint(Model): + """A model that applies a hard constraint to the output of another model. + + Parameters + ---------- + model : Model + The model that should be constrained. + constraint : callable + The constraint that should be applied to the output of the model. + The constraint function can take as an input the input and output + of the model. It needs to return all outputs of the model after the + constraint has been applied. + Even if the model returns two values u, v but only u needs to have + a hard constraint, the constraint function should return both u and v. + """ + + def __init__(self, model, constraint): + super().__init__(model.input_space, model.output_space) + self.model = model + self.constraint = UserFunction(constraint) + + def forward(self, points): + model_out = self.model(points) + combine_in_and_out = points.join(model_out) + constrained_out = self.constraint(combine_in_and_out.coordinates) + if isinstance(constrained_out, torch.Tensor): + return Points(constrained_out, self.output_space) + elif isinstance(constrained_out, (tuple, list)): + return Points(torch.column_stack(constrained_out), self.output_space) + else: + raise AssertionError("Constraint function should return a tensor or a tuple of tensors.") \ No newline at end of file diff --git a/src/torchphysics/problem/conditions/__init__.py b/src/torchphysics/problem/conditions/__init__.py index c815db44..5bc7a879 100644 --- a/src/torchphysics/problem/conditions/__init__.py +++ b/src/torchphysics/problem/conditions/__init__.py @@ -26,8 +26,7 @@ from .deeponet_condition import ( DeepONetSingleModuleCondition, PIDeepONetCondition, - DeepONetDataCondition, +# DeepONetDataCondition, ) - -from .variational_condition import VariationalPINNCondition \ No newline at end of file +from .operator_condition import OperatorCondition, PIOperatorCondition \ No newline at end of file diff --git a/src/torchphysics/problem/conditions/deeponet_condition.py b/src/torchphysics/problem/conditions/deeponet_condition.py index ce0c3f8e..298d9c9f 100644 --- a/src/torchphysics/problem/conditions/deeponet_condition.py +++ b/src/torchphysics/problem/conditions/deeponet_condition.py @@ -1,6 +1,6 @@ import torch -from .condition import Condition, SquaredError, DataCondition +from .condition import Condition, SquaredError from ...models import Parameter from ...utils import UserFunction from ...models import DeepONet @@ -10,11 +10,12 @@ class DeepONetSingleModuleCondition(Condition): def __init__( self, - deeponet_model, - function_set, - input_sampler, + deeponet_model : DeepONet, + branch_function_sampler, + trunk_points_sampler, residual_fn, error_fn, + data_sampler=None, reduce_fn=torch.mean, name="singlemodulecondition", track_gradients=True, @@ -24,111 +25,96 @@ def __init__( ): super().__init__(name=name, weight=weight, track_gradients=track_gradients) self.net = deeponet_model - assert isinstance(self.net, DeepONet) - self.function_set = function_set + self.branch_function_sampler = branch_function_sampler + self.data_sampler = data_sampler self.parameter = parameter self.register_parameter(name + "_params", self.parameter.as_tensor) - self.input_sampler = input_sampler + self.trunk_points_sampler = trunk_points_sampler self.residual_fn = UserFunction(residual_fn) self.error_fn = error_fn self.reduce_fn = reduce_fn self.data_functions = self._setup_data_functions( - data_functions, self.input_sampler + data_functions, self.trunk_points_sampler ) - self.eval_function_set = ( + self.eval_function_set_for_residual = ( len( - self.function_set.function_space.output_space.variables + self.branch_function_sampler.function_set.function_space.output_space.variables & set(self.residual_fn.args) ) > 0 + or + self.data_sampler is not None ) def forward(self, device="cpu", iteration=None): - # 1) if necessary, sample input function and evaluate branch net - self.net._forward_branch( - self.function_set, iteration_num=iteration, device=device - ) - - # 2) sample output points - if self.input_sampler.is_adaptive: - x = self.input_sampler.sample_points( + # 1) sample trunk input points + if self.trunk_points_sampler.is_adaptive: + trunk_points = self.trunk_points_sampler.sample_points( unreduced_loss=self.last_unreduced_loss, device=device ) self.last_unreduced_loss = None else: - x = self.input_sampler.sample_points(device=device) - x = x.unsqueeze(0).repeat(len(self.function_set), 1, 1) - x_coordinates, x = x.track_coord_gradients() + trunk_points = self.trunk_points_sampler.sample_points(device=device) + + # TODO: make this more memory efficient (e.g. in DeepONet we know when data is just copied???) + trunk_points = trunk_points.unsqueeze(0).repeat( + self.branch_function_sampler.n_functions, 1, 1 + ) + trunk_coordinates, trunk_points = trunk_points.track_coord_gradients() + + # 2) sample branch inputs + branch_functions = self.branch_function_sampler.sample_functions(device) + if callable(branch_functions): + branch_function_input = branch_functions(self.net.branch.grid) + else: + branch_function_input = branch_functions + + # 3) create additional data for residual evaluation (only if necessary) + if self.eval_function_set_for_residual: + if self.data_sampler is not None: + data = self.data_sampler.sample_functions(device) + if callable(data): + data = data(trunk_points) + elif callable(branch_functions): + data = branch_functions(trunk_points) + else: + data = branch_functions - # 3) evaluate model (only trunk net) - y = self.net(x, device=device) + # 4) evaluate model + model_out = self.net(trunk_points, branch_function_input, device=device) - # 4) evaluate condition - data = {} + # 5) evaluate other needed functions + data_fn = {} for fun in self.data_functions: - data[fun] = self.data_functions[fun](x_coordinates) - # now check whether evaluation of function set in output points is necessary, i.e - # whether the functions are part of the loss - function_set_output = {} - if self.eval_function_set: - function_set_output = self.function_set.create_function_batch( - x[0, :, :] - ).coordinates - - unreduced_loss = self.error_fn( - self.residual_fn( - { - **y.coordinates, - **x_coordinates, - **function_set_output, - **self.parameter.coordinates, - **data, - } - ) - ) + data_fn[fun] = self.data_functions[fun](trunk_coordinates) + + # 6) evaluate the residual + input_dict = { + **model_out.coordinates, + **trunk_coordinates, + **self.parameter.coordinates, + **data_fn, + } + + if self.eval_function_set_for_residual: + input_dict = {**input_dict, **data.coordinates} - if self.input_sampler.is_adaptive: + unreduced_loss = self.error_fn(self.residual_fn(input_dict)) + + if self.trunk_points_sampler.is_adaptive: self.last_unreduced_loss = unreduced_loss return self.reduce_fn(unreduced_loss) - class PIDeepONetCondition(DeepONetSingleModuleCondition): """ A condition that minimizes the mean squared error of the given residual, as required in the framework of physics-informed DeepONets [#]_. - Parameters - ------- - deeponet_model : torchphysics.models.DeepONet - The DeepONet-model, consisting of trunk and branch net that should be optimized. - function_set : torchphysics.domains.FunctionSet - A FunctionSet that provides the different input functions for the branch net. - input_sampler : torchphysics.samplers.PointSampler - A sampler that creates the points inside the domain of the residual function, - could be an inner or a boundary domain. - residual_fn : callable - A user-defined function that computes the residual (unreduced loss) from - inputs and outputs of the model, e.g. by using utils.differentialoperators - and/or domain.normal - data_functions : dict - A dictionary of user-defined functions and their names (as keys). Can be - used e.g. for right sides in PDEs or functions in boundary conditions. - track_gradients : bool - Whether gradients w.r.t. the inputs should be tracked during training or - not. Defaults to true, since this is needed to compute differential operators - in PINNs. - parameter : Parameter - A Parameter that can be used in the residual_fn and should be learned in - parallel, e.g. based on data (in an additional DataCondition). - name : str - The name of this condition which will be monitored in logging. - weight : float - The weight multiplied with the loss of this condition during - training. + ...... Notes ----- @@ -141,10 +127,11 @@ class PIDeepONetCondition(DeepONetSingleModuleCondition): def __init__( self, deeponet_model, - function_set, - input_sampler, + branch_function_sampler, + trunk_points_sampler, residual_fn, - name="pinncondition", + data_sampler=None, + name="pi_deeponet_condition", track_gradients=True, data_functions={}, parameter=Parameter.empty(), @@ -152,9 +139,10 @@ def __init__( ): super().__init__( deeponet_model, - function_set, - input_sampler, + branch_function_sampler, + trunk_points_sampler, residual_fn=residual_fn, + data_sampler=data_sampler, error_fn=SquaredError(), reduce_fn=torch.mean, name=name, @@ -165,77 +153,236 @@ def __init__( ) -class DeepONetDataCondition(DataCondition): - """ - A condition that fits a single given module to data (handed through a PyTorch - dataloader). - - Parameters - ---------- - module : torchphysics.Model - The torch module which should be fitted to data. - dataloader : torch.utils.DataLoader - A PyTorch dataloader which supplies the iterator to load data-target pairs - from some given dataset. Data and target should be handed as points in input - or output spaces, i.e. with the correct point object. - norm : int or 'inf' - The 'norm' which should be computed for evaluation. If 'inf', maximum norm will - be used. Else, the result will be taken to the n-th potency (without computing the - root!) - constrain_fn : callable, optional - A additional transformation that will be applied to the network output. - The function gets as an input all the trunk inputs (e.g. space, time values) - and the corresponding outputs of the final model (the solution approximation). - Can be used to enforce some conditions (e.g. boundary values, or scaling the output) - root : float - the n-th root to be computed to obtain the final loss. E.g., if norm=2, root=2, the - loss is the 2-norm. - use_full_dataset : bool - Whether to perform single iterations or compute the error on the whole dataset during - forward call. The latter can especially be useful during validation. - name : str - The name of this condition which will be monitored in logging. - weight : float - The weight multiplied with the loss of this condition during - training. - """ +# class DeepONetSingleModuleCondition(Condition): - def __init__( - self, - module, - dataloader, - norm, - constrain_fn=None, - root=1.0, - use_full_dataset=False, - name="datacondition", - weight=1.0, - ): - super().__init__( - module=module, - dataloader=dataloader, - norm=norm, - root=root, - use_full_dataset=use_full_dataset, - name=name, - weight=weight, - constrain_fn=constrain_fn, - ) - assert isinstance(self.module, DeepONet) - - def _compute_dist(self, batch, device): - branch_in, trunk_in, out = batch - branch_in, trunk_in, out = ( - branch_in.to(device), - trunk_in.to(device), - out.to(device), - ) - self.module.branch(branch_in) - model_out = self.module(trunk_in) - if self.constrain_fn: - model_out = self.constrain_fn( - {**model_out.coordinates, **trunk_in.coordinates} - ) - else: - model_out = model_out.as_tensor - return torch.abs(model_out - out.as_tensor) +# def __init__( +# self, +# deeponet_model, +# function_set, +# input_sampler, +# residual_fn, +# error_fn, +# reduce_fn=torch.mean, +# name="singlemodulecondition", +# track_gradients=True, +# data_functions={}, +# parameter=Parameter.empty(), +# weight=1.0, +# ): +# super().__init__(name=name, weight=weight, track_gradients=track_gradients) +# self.net = deeponet_model +# assert isinstance(self.net, DeepONet) +# self.function_set = function_set + +# self.parameter = parameter +# self.register_parameter(name + "_params", self.parameter.as_tensor) +# self.input_sampler = input_sampler + +# self.residual_fn = UserFunction(residual_fn) +# self.error_fn = error_fn +# self.reduce_fn = reduce_fn +# self.data_functions = self._setup_data_functions( +# data_functions, self.input_sampler +# ) + +# self.eval_function_set = ( +# len( +# self.function_set.function_space.output_space.variables +# & set(self.residual_fn.args) +# ) +# > 0 +# ) + +# def forward(self, device="cpu", iteration=None): +# # 1) if necessary, sample input function and evaluate branch net +# self.net._forward_branch( +# self.function_set, iteration_num=iteration, device=device +# ) + +# # 2) sample output points +# if self.input_sampler.is_adaptive: +# x = self.input_sampler.sample_points( +# unreduced_loss=self.last_unreduced_loss, device=device +# ) +# self.last_unreduced_loss = None +# else: +# x = self.input_sampler.sample_points(device=device) +# x = x.unsqueeze(0).repeat(len(self.function_set), 1, 1) +# x_coordinates, x = x.track_coord_gradients() + +# # 3) evaluate model (only trunk net) +# y = self.net(x, device=device) + +# # 4) evaluate condition +# data = {} +# for fun in self.data_functions: +# data[fun] = self.data_functions[fun](x_coordinates) +# # now check whether evaluation of function set in output points is necessary, i.e +# # whether the functions are part of the loss +# function_set_output = {} +# if self.eval_function_set: +# function_set_output = self.function_set.create_function_batch( +# x[0, :, :] +# ).coordinates + +# unreduced_loss = self.error_fn( +# self.residual_fn( +# { +# **y.coordinates, +# **x_coordinates, +# **function_set_output, +# **self.parameter.coordinates, +# **data, +# } +# ) +# ) + +# if self.input_sampler.is_adaptive: +# self.last_unreduced_loss = unreduced_loss + +# return self.reduce_fn(unreduced_loss) + + +# class PIDeepONetCondition(DeepONetSingleModuleCondition): +# """ +# A condition that minimizes the mean squared error of the given residual, as +# required in the framework of physics-informed DeepONets [#]_. + +# Parameters +# ------- +# deeponet_model : torchphysics.models.DeepONet +# The DeepONet-model, consisting of trunk and branch net that should be optimized. +# function_set : torchphysics.domains.FunctionSet +# A FunctionSet that provides the different input functions for the branch net. +# input_sampler : torchphysics.samplers.PointSampler +# A sampler that creates the points inside the domain of the residual function, +# could be an inner or a boundary domain. +# residual_fn : callable +# A user-defined function that computes the residual (unreduced loss) from +# inputs and outputs of the model, e.g. by using utils.differentialoperators +# and/or domain.normal +# data_functions : dict +# A dictionary of user-defined functions and their names (as keys). Can be +# used e.g. for right sides in PDEs or functions in boundary conditions. +# track_gradients : bool +# Whether gradients w.r.t. the inputs should be tracked during training or +# not. Defaults to true, since this is needed to compute differential operators +# in PINNs. +# parameter : Parameter +# A Parameter that can be used in the residual_fn and should be learned in +# parallel, e.g. based on data (in an additional DataCondition). +# name : str +# The name of this condition which will be monitored in logging. +# weight : float +# The weight multiplied with the loss of this condition during +# training. + +# Notes +# ----- +# .. [#] Wang, Sifan and Wang, Hanwen and Perdikaris, +# "Learning the solution operator of parametric partial +# differential equations with physics-informed DeepOnets", +# https://arxiv.org/abs/2103.10974, 2021. +# """ + +# def __init__( +# self, +# deeponet_model, +# function_set, +# input_sampler, +# residual_fn, +# name="pinncondition", +# track_gradients=True, +# data_functions={}, +# parameter=Parameter.empty(), +# weight=1.0, +# ): +# super().__init__( +# deeponet_model, +# function_set, +# input_sampler, +# residual_fn=residual_fn, +# error_fn=SquaredError(), +# reduce_fn=torch.mean, +# name=name, +# track_gradients=track_gradients, +# data_functions=data_functions, +# parameter=parameter, +# weight=weight, +# ) + + +# class DeepONetDataCondition(DataCondition): +# """ +# A condition that fits a single given module to data (handed through a PyTorch +# dataloader). + +# Parameters +# ---------- +# module : torchphysics.Model +# The torch module which should be fitted to data. +# dataloader : torch.utils.DataLoader +# A PyTorch dataloader which supplies the iterator to load data-target pairs +# from some given dataset. Data and target should be handed as points in input +# or output spaces, i.e. with the correct point object. +# norm : int or 'inf' +# The 'norm' which should be computed for evaluation. If 'inf', maximum norm will +# be used. Else, the result will be taken to the n-th potency (without computing the +# root!) +# constrain_fn : callable, optional +# A additional transformation that will be applied to the network output. +# The function gets as an input all the trunk inputs (e.g. space, time values) +# and the corresponding outputs of the final model (the solution approximation). +# Can be used to enforce some conditions (e.g. boundary values, or scaling the output) +# root : float +# the n-th root to be computed to obtain the final loss. E.g., if norm=2, root=2, the +# loss is the 2-norm. +# use_full_dataset : bool +# Whether to perform single iterations or compute the error on the whole dataset during +# forward call. The latter can especially be useful during validation. +# name : str +# The name of this condition which will be monitored in logging. +# weight : float +# The weight multiplied with the loss of this condition during +# training. +# """ + +# def __init__( +# self, +# module, +# dataloader, +# norm, +# constrain_fn=None, +# root=1.0, +# use_full_dataset=False, +# name="datacondition", +# weight=1.0, +# ): +# super().__init__( +# module=module, +# dataloader=dataloader, +# norm=norm, +# root=root, +# use_full_dataset=use_full_dataset, +# name=name, +# weight=weight, +# constrain_fn=constrain_fn, +# ) +# assert isinstance(self.module, DeepONet) + +# def _compute_dist(self, batch, device): +# branch_in, trunk_in, out = batch +# branch_in, trunk_in, out = ( +# branch_in.to(device), +# trunk_in.to(device), +# out.to(device), +# ) +# self.module.branch(branch_in) +# model_out = self.module(trunk_in) +# if self.constrain_fn: +# model_out = self.constrain_fn( +# {**model_out.coordinates, **trunk_in.coordinates} +# ) +# else: +# model_out = model_out.as_tensor +# return torch.abs(model_out - out.as_tensor) diff --git a/src/torchphysics/problem/conditions/operator_condition.py b/src/torchphysics/problem/conditions/operator_condition.py new file mode 100644 index 00000000..5345a831 --- /dev/null +++ b/src/torchphysics/problem/conditions/operator_condition.py @@ -0,0 +1,104 @@ +import torch + +from .condition import Condition, SquaredError +from ...utils import UserFunction +from ...models.deeponet.deeponet import DeepONet + +class OperatorCondition(Condition): + + def __init__( + self, + module, + input_function_sampler, + output_function_sampler, + residual_fn=None, + reduce_fn=torch.mean, + error_fn=SquaredError(), + name="operator_condition", + weight=1.0, + ): + super().__init__(name=name, weight=weight, track_gradients=False) + assert input_function_sampler.function_set.is_discretized, \ + "This condition needs discretized function sets" + assert output_function_sampler.function_set.is_discretized, \ + "This condition needs discretized function sets" + + self.module = module + self.input_function_sampler = input_function_sampler + self.output_function_sampler = output_function_sampler + + if residual_fn: + self.residual_fn = UserFunction(residual_fn) + else: + self.residual_fn = None + + self.error_fn = error_fn + self.reduce_fn = reduce_fn + + self.module_is_deeponet = isinstance(self.module, DeepONet) + + def forward(self, device="cpu", iteration=None): + input_functions = self.input_function_sampler.sample_functions(device=device) + output_functions = self.output_function_sampler.sample_functions(device=device) + + if self.module_is_deeponet: + model_out = self.module(None, input_functions) + else: + model_out = self.module(input_functions) + + if self.residual_fn: + first_error = self.residual_fn( + {**output_functions.coordinates, + **model_out.coordinates, + **input_functions.coordinates} + ) + else: + first_error = model_out.as_tensor - output_functions.as_tensor + + return self.reduce_fn(self.error_fn(first_error)) + + + +class PIOperatorCondition(Condition): + + def __init__( + self, + module, + input_function_sampler, + residual_fn, + reduce_fn=torch.mean, + error_fn=SquaredError(), + name="pi_operator_condition", + weight=1.0, + ): + super().__init__(name=name, weight=weight, track_gradients=False) + assert input_function_sampler.function_set.is_discretized, \ + "This condition needs discretized function sets" + + self.module = module + self.input_function_sampler = input_function_sampler + + if residual_fn: + self.residual_fn = UserFunction(residual_fn) + else: + self.residual_fn = None + + self.error_fn = error_fn + self.reduce_fn = reduce_fn + + self.module_is_deeponet = isinstance(self.module, DeepONet) + + def forward(self, device="cpu", iteration=None): + input_functions = self.input_function_sampler.sample_functions(device=device) + + if self.module_is_deeponet: + model_out = self.module(None, input_functions) + else: + model_out = self.module(input_functions) + + first_error = self.residual_fn( + {**model_out.coordinates, + **input_functions.coordinates} + ) + + return self.reduce_fn(self.error_fn(first_error)) \ No newline at end of file diff --git a/src/torchphysics/problem/conditions/variational_condition.py b/src/torchphysics/problem/conditions/variational_condition.py deleted file mode 100644 index fac216d3..00000000 --- a/src/torchphysics/problem/conditions/variational_condition.py +++ /dev/null @@ -1,41 +0,0 @@ -import torch -from .condition import SingleModuleCondition, SquaredError -from ...models import Parameter - - -class VariationalPINNCondition(SingleModuleCondition): - - def __init__(self, module, residual_fn, sampler, test_fn_set, track_gradients=True, - data_functions={}, parameter=Parameter.empty(), name='pinncondition', - weight=1.0): - super().__init__(module, sampler, residual_fn, error_fn=SquaredError(), - reduce_fn=torch.mean, name=name, track_gradients=track_gradients, - data_functions=data_functions, parameter=parameter, weight=weight) - self.test_fn_set = test_fn_set - - - def _move_static_data(self, device): - super()._move_static_data(device) - self.test_fn_set.to(device) - - - def forward(self, device='cpu', iteration=None): - x = self.sampler.sample_points(device=device) - x_coordinates, x = x.track_coord_gradients() - - y = self.module(x) - - data = {} - for fun in self.data_functions: - data[fun] = self.data_functions[fun](x_coordinates) - - test_fn = self.test_fn_set(x_coordinates) - - test_space_parameters = {"quad_weights": self.test_fn_set.get_quad_weights(len(y.as_tensor))} - - unreduced_loss = self.error_fn(self.residual_fn({**y.coordinates, - **x_coordinates, - **test_space_parameters, - **test_fn.coordinates, - **data})) - return self.reduce_fn(unreduced_loss) \ No newline at end of file diff --git a/src/torchphysics/problem/domains/__init__.py b/src/torchphysics/problem/domains/__init__.py index 685bc888..31a5df69 100644 --- a/src/torchphysics/problem/domains/__init__.py +++ b/src/torchphysics/problem/domains/__init__.py @@ -34,12 +34,21 @@ # from .domain2D.shapely_polygon import ShapelyPolygon # 3D-domains: from .domain3D.sphere import Sphere +from .domain3D.box import Box + +# ND-domains: +from .domainND.hypercube import HyperCube # from .domain3D.trimesh_polyhedron import TrimeshPolyhedron # Function domains: -from .functionsets.functionset import FunctionSet, CustomFunctionSet, TestFunctionSet -from .functionsets.FE_functionset import FEFunctionSet -from .functionsets.harmonic_functionset import HarmonicFunctionSet1D +from .functionsets.functionset import FunctionSet, DiscreteFunctionSet, DiscretizedFunctionSet +from .functionsets.custom_functionset import CustomFunctionSet +from .functionsets.harmonic_functionset import (HarmonicFunctionSet1D, + HarmonicFunctionSet2D, + HarmonicFunctionSet3D) +from .functionsets.data_functionset import DataFunctionSet +from .functionsets.grf_functionset import GRFFunctionSet +from .functionsets.functionset_operations import FunctionSetTransform # Domain transforms: from .domainoperations.translate import Translate from .domainoperations.rotate import Rotate diff --git a/src/torchphysics/problem/domains/domain.py b/src/torchphysics/problem/domains/domain.py index 9e8fde89..ae89fba1 100644 --- a/src/torchphysics/problem/domains/domain.py +++ b/src/torchphysics/problem/domains/domain.py @@ -121,6 +121,17 @@ def __add__(self, other): return UnionDomain(self, other) + def __or__(self, other): + """Creates the union of the two input domains. + + Parameters + ---------- + other : Domain + The other domain that should be united with the domain. + Has to be of the same dimension. + """ + return self.__add__(other) + def __sub__(self, other): """Creates the cut of domain other from self. @@ -133,7 +144,7 @@ def __sub__(self, other): if self.space != other.space: raise ValueError("""complemented domains should lie in the same space.""") from .domainoperations.cut import CutDomain - + return CutDomain(self, other) def __and__(self, other): diff --git a/src/torchphysics/problem/domains/domain2D/parallelogram.py b/src/torchphysics/problem/domains/domain2D/parallelogram.py index 9c6eba52..2a420fe1 100644 --- a/src/torchphysics/problem/domains/domain2D/parallelogram.py +++ b/src/torchphysics/problem/domains/domain2D/parallelogram.py @@ -5,7 +5,7 @@ class Parallelogram(Domain): - """Class for arbitrary parallelograms, even if time dependet + """Class for arbitrary parallelograms, even if time dependent will always stay a parallelogram. Parameters @@ -272,7 +272,7 @@ def normal(self, points, params=Points.empty(), device="cpu"): self._add_local_normal_vector( normals, bary_x, bary_y, normal_dir_1, normal_dir_2, 1.0 ) - # scale normal vectors if there where in a corner: + # scale normal vectors if they are in a corner: return torch.divide(normals, torch.linalg.norm(normals, dim=1).reshape(-1, 1)) def _add_local_normal_vector( diff --git a/src/torchphysics/problem/domains/domain3D/__init__.py b/src/torchphysics/problem/domains/domain3D/__init__.py index 7acd80ea..bc27269f 100644 --- a/src/torchphysics/problem/domains/domain3D/__init__.py +++ b/src/torchphysics/problem/domains/domain3D/__init__.py @@ -1 +1,2 @@ from .sphere import Sphere +from .box import Box diff --git a/src/torchphysics/problem/domains/domain3D/box.py b/src/torchphysics/problem/domains/domain3D/box.py new file mode 100644 index 00000000..3e1eb162 --- /dev/null +++ b/src/torchphysics/problem/domains/domain3D/box.py @@ -0,0 +1,338 @@ +import torch + +from ..domain import Domain, BoundaryDomain +from ...spaces import Points + + +class Box(Domain): + """Class for three dimensional boxes. + + Parameters + ---------- + space : Space + The space of this object. + origin : array_like or callable + The origin of this box (one corner). + width, height, depth : float or callable + The size of the box in the three space dimensions. + """ + def __init__(self, space, origin, width, height, depth): + assert space.dim == 3 + origin, width, height, depth = self.transform_to_user_functions( + origin, width, height, depth + ) + self.origin = origin + self.width = width + self.height = height + self.depth = depth + super().__init__(space=space, dim=3) + self.set_necessary_variables(self.origin, self.width, self.height, self.depth) + + def __call__(self, **data): + new_origin = self.origin.partially_evaluate(**data) + new_origin = self._check_shape_of_evaluated_user_function(new_origin) + width = self.width.partially_evaluate(**data) + height = self.height.partially_evaluate(**data) + depth = self.depth.partially_evaluate(**data) + return Box(self.space, new_origin, width, height, depth) + + def _check_shape_of_evaluated_user_function(self, domain_param): + if isinstance(domain_param, torch.Tensor): + if len(domain_param.shape) > 1: + return domain_param[0, :] + return domain_param + + def _eval_box_params(self, params, device): + eval_origin = self.origin(params, device).reshape(-1, 3) + eval_width = self.width(params, device).reshape(-1, 1) + eval_height = self.height(params, device).reshape(-1, 1) + eval_depth = self.depth(params, device).reshape(-1, 1) + return eval_origin, eval_width, eval_height, eval_depth + + def _get_volume(self, params=Points.empty(), device="cpu"): + _, eval_width, eval_height, eval_depth = self._eval_box_params(params, device) + return eval_width * eval_height * eval_depth + + def bounding_box(self, params=Points.empty(), device="cpu"): + eval_origin, eval_width, eval_height, eval_depth = \ + self._eval_box_params(params, device) + + min_values = torch.min(eval_origin, dim=0)[0] + bounds = [] + scale_list = [eval_width, eval_height, eval_depth] + for i in range(self.space.dim): + bounds.append(min_values[i]) + bounds.append(torch.max(eval_origin[:, i:i+1] + scale_list[i]).item()) + + return torch.tensor(bounds, device=device) + + def _contains(self, points, params=Points.empty()): + eval_origin, eval_width, eval_height, eval_depth = \ + self._eval_box_params(params, points.device) + + points = points[:, list(self.space.keys())].as_tensor + points -= eval_origin + inside = torch.ones((len(points), 1), dtype=torch.bool) + scale_list = [eval_width, eval_height, eval_depth] + + for i in range(self.space.dim): + in_current = torch.logical_and(0 <= points[:, i:i+1], + points[:, i:i+1] <= scale_list[i]) + inside = torch.logical_and(in_current, inside) + + return inside.reshape(-1, 1) + + def sample_random_uniform(self, n=None, d=None, + params=Points.empty(), device="cpu"): + if d: n = self.compute_n_from_density(d, params) + eval_origin, eval_width, eval_height, eval_depth = \ + self._eval_box_params(params, device) + + num_of_params = self.len_of_params(params) + points = torch.rand((num_of_params, n, 3), device=device) + points[..., 0:1] *= eval_width.unsqueeze(1) + points[..., 1:2] *= eval_height.unsqueeze(1) + points[..., 2:3] *= eval_depth.unsqueeze(1) + points += eval_origin[:, None, :] + return Points(points.reshape(-1, self.space.dim), self.space) + + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): + if d: + n = self.compute_n_from_density(d, params) + eval_origin, eval_width, eval_height, eval_depth = \ + self._eval_box_params(params, device) + + grid = self._compute_grid(n, eval_width, eval_height, eval_depth, device) + + if not d: + # if the number of points is specified we have to be sure to sample + # the right amount + grid = self._grid_enough_points(n, grid, device) + + scale_list = [eval_width, eval_height, eval_depth] + for i in range(self.space.dim): + grid[:, i:i+1] *= scale_list[i] + + grid += eval_origin + + return Points(grid, self.space) + + def _compute_grid(self, n, w, h, d, device): + volume = w*h*d + # scale the number of point w.r.t. the shape of the box + n_scale = torch.pow(n / volume, 1.0/3.0) + n_z = int(d * n_scale) + n_x = int(w * n_scale) + n_y = int(h * n_scale) + x = torch.linspace(0, 1, n_x + 2, device=device)[1:-1] + y = torch.linspace(0, 1, n_y + 2, device=device)[1:-1] + z = torch.linspace(0, 1, n_z + 2, device=device)[1:-1] + grid = torch.permute(torch.stack(torch.meshgrid((x, y, z))), (3, 2, 1, 0)) + return grid.reshape(-1, 3) + + def _grid_enough_points(self, n, grid, device): + if len(grid) < n: + random_points = torch.rand((n - len(grid), 3), device=device) + grid = torch.cat((grid, random_points), dim=0) + return grid + + @property + def boundary(self): + return BoxBoundary(self) + + +class BoxBoundary(BoundaryDomain): + + def __init__(self, domain): + assert isinstance(domain, Box) + super().__init__(domain) + + def _contains(self, points, params=Points.empty()): + eval_origin, eval_width, eval_height, eval_depth = \ + self.domain._eval_box_params(params, points.device) + + points = points[:, list(self.space.keys())].as_tensor + points -= eval_origin + + on_boundary = torch.zeros((len(points), 1), dtype=torch.bool) + scale_list = [eval_width, eval_height, eval_depth] + + for i in range(self.space.dim): + # check current dir. on boundary + close_0 = torch.isclose(points[:, i:i+1], + torch.tensor(0.0, device=points.device)) + close_size = torch.isclose(points[:, i:i+1], scale_list[i]) + # combine + on_boundary |= (close_0 | close_size) + + # also need to check if points are in the box (one dimension is on the + # boundary so the other dimension need to lay inside) + in_current = \ + torch.logical_and(0 <= points[:, 0:1], points[:, 0:1] <= scale_list[0]) &\ + torch.logical_and(0 <= points[:, 1:2], points[:, 1:2] <= scale_list[1]) &\ + torch.logical_and(0 <= points[:, 2:3], points[:, 2:3] <= scale_list[2]) + + on_boundary &= in_current + + return on_boundary.reshape(-1, 1) + + def _get_volume(self, params=Points.empty(), device="cpu"): + _, eval_width, eval_height, eval_depth = \ + self.domain._eval_box_params(params, device=device) + + area_xy = eval_width * eval_height + area_xz = eval_width * eval_depth + area_yz = eval_depth * eval_height + return 2 * (area_xy + area_xz + area_yz).reshape(-1, 1) + + def sample_random_uniform(self, n=None, d=None, + params=Points.empty(), device="cpu"): + if d: + n = self.compute_n_from_density(d, params) + eval_origin, eval_width, eval_height, eval_depth = \ + self.domain._eval_box_params(params, device=device) + + # Amount of points need to scale with surface area + area_xy = eval_width * eval_height + area_xz = eval_width * eval_depth + area_yz = eval_depth * eval_height + total_area = (area_xy + area_xz + area_yz).reshape(-1, 1) + + area_list = [area_yz, area_xz, area_xy] + scale_list = [eval_width, eval_height, eval_depth] + + num_of_params = self.len_of_params(params) + points = torch.zeros((num_of_params, n, 3), device=device) + indices = torch.arange(n).view(1, n) + old_n_scale = torch.zeros_like(area_xy) + + # We iterate over each direction and sample on each side seperately. + for i in range(self.space.dim): + if i < self.space.dim - 1: + n_scale =(n * area_list[i] / total_area).int() + else: # last dimension gets all remaining points + n_scale = n - old_n_scale + + # Note: we sample total amount of n points, since the domain + # could be dependent on other parameters which leads to different + # scaling of the surface area and therefore to different amount + # of points depending on the parameters. + # To handle all cases we sample more points and then override + # only the needed points. + current_points = torch.rand((num_of_params, n, 3), device=device) + current_shift = torch.randint(0, 2, (num_of_params, n, 1), device=device) + + current_points[:, :, i:i+1] = current_shift * scale_list[i].unsqueeze(1) + i_mod_1 = (i+1)%3 + i_mod_2 = (i+2)%3 + current_points[:, :, i_mod_1:i_mod_1+1] *= scale_list[i_mod_1].unsqueeze(1) + current_points[:, :, i_mod_2:i_mod_2+1] *= scale_list[i_mod_2].unsqueeze(1) + + mask = torch.logical_or(indices >= n_scale+old_n_scale, indices < old_n_scale) + mask = mask.unsqueeze(-1).repeat( + (1 if mask.shape[0] > 1 else num_of_params, 1, 3) + ) + # set not needed values to 0 + current_points[mask] = 0.0 + + old_n_scale += n_scale + points += current_points + + points += eval_origin[:, None, :] + return Points(points.reshape(-1, self.space.dim), self.space) + + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): + if d: + n = self.compute_n_from_density(d, params) + eval_origin, eval_width, eval_height, eval_depth = \ + self.domain._eval_box_params(params, device=device) + + # Amount of points need to scale with surface area + area_xy = eval_width * eval_height + area_xz = eval_width * eval_depth + area_yz = eval_depth * eval_height + total_area = (area_xy + area_xz + area_yz).reshape(-1, 1) + + area_list = [area_yz, area_xz, area_xy] + scale_list = [eval_width, eval_height, eval_depth] + permute_list = [[0, 1, 2], [2, 0, 1], [1, 2, 0]] + difference_list = [[eval_height, eval_depth], + [eval_depth, eval_width], + [eval_width, eval_height]] + points = torch.zeros((n, 3), device=device) + current_n = 0 + + # We iterate over each direction and sample on each side seperately. + for i in range(self.space.dim): + if i < self.space.dim - 1: + n_scale = int(n * area_list[i] / total_area) + else: # last dimension gets all remaining points + n_scale = n - current_n + + n_1 = int(torch.sqrt(n_scale/2.0 * difference_list[i][0]/difference_list[i][1])) + n_2 = int(torch.sqrt(n_scale/2.0 * difference_list[i][1]/difference_list[i][0])) + + grid_1 = torch.linspace(0, 1, n_1+1, device=device) + grid_2 = torch.linspace(0, 1, n_2+1, device=device) + # Bottom and top side, always create a grid that contains two edges. + # When we stick all sides together we obtain therefore all edges + for k in range(2): + n_prod = n_1 * n_2 + if k == 0: + grid = torch.permute( + torch.stack(torch.meshgrid((grid_1[:-1], grid_2[:-1]))), (2, 1, 0) + ).reshape(-1, 2) + grid = torch.column_stack( + (torch.zeros((len(grid), 1), device=device), grid) + ) + else: + grid = torch.permute( + torch.stack(torch.meshgrid((grid_1[1:], grid_2[1:]))), (2, 1, 0) + ).reshape(-1, 2) + # add some random points if no perfect grid was created: + n_difference = n_scale - (n_prod + len(grid)) + if n_difference > 0: + random_points = torch.rand((n_difference, 2), device=device) + grid = torch.cat((grid, random_points), dim=0) + n_prod = len(grid) + + grid = torch.column_stack( + (scale_list[i] * torch.ones((len(grid), 1), device=device), grid) + ) + + i_mod_1 = (i+1)%3 + i_mod_2 = (i+2)%3 + grid[:, 1:2] *= scale_list[i_mod_1] + grid[:, 2:3] *= scale_list[i_mod_2] + + grid = grid[:, permute_list[i]] + points[current_n:current_n+n_prod] = grid + + current_n += n_prod + + points += eval_origin + return Points(points.reshape(-1, self.space.dim), self.space) + + def normal(self, points, params=Points.empty(), device="cpu"): + points, params, device = self._transform_input_for_normals( + points, params, device + ) + eval_origin, eval_width, eval_height, eval_depth = \ + self.domain._eval_box_params(params, device=device) + + points = points[:, list(self.space.keys())].as_tensor + points -= eval_origin + + normals = torch.zeros_like(points, device=device) + scale_list = [eval_width, eval_height, eval_depth] + + for i in range(self.space.dim): + # check current dir. on boundary + close_0 = torch.isclose(points[:, i:i+1], + torch.tensor(0.0, device=points.device)).squeeze(-1) + close_size = torch.isclose(points[:, i:i+1], scale_list[i]).squeeze(-1) + normals[close_0, i] = -1.0 + normals[close_size, i] = 1.0 + + # scale normal vectors if they are in a corner: + return torch.divide(normals, torch.linalg.norm(normals, dim=1).reshape(-1, 1)) \ No newline at end of file diff --git a/src/torchphysics/problem/domains/domainND/__init__.py b/src/torchphysics/problem/domains/domainND/__init__.py new file mode 100644 index 00000000..4d974591 --- /dev/null +++ b/src/torchphysics/problem/domains/domainND/__init__.py @@ -0,0 +1 @@ +from .hypercube import HyperCube \ No newline at end of file diff --git a/src/torchphysics/problem/domains/domainND/hypercube.py b/src/torchphysics/problem/domains/domainND/hypercube.py new file mode 100644 index 00000000..d376d833 --- /dev/null +++ b/src/torchphysics/problem/domains/domainND/hypercube.py @@ -0,0 +1,80 @@ +import torch + +from ..domain import Domain +from ...spaces import Points + + +class HyperCube(Domain): + """ A n-dimensional cube for sampling parameters. + + Parameters + ---------- + space : Space + The space of this object. + lower_bounds : float or array_like + The lower bound for each dimension of this hypercube. If a single float + is passed in, we assume that all dimensions have this value + as a lower bound. + upper_bounds : float or array_like + The upper bound for each dimension of this hypercube. If a single float + is passed in, we assume that all dimensions have this value + as an upper bound. + + Note + ---- + This class is only meant for randomly sampling parameters in high dimensional + spaces. Currently many functionalites of other domains are not supported in this + class. This includes, calling `.boundary`, checking if points + are contained in this HyperCube and also domain operations. + Additionally, HyperCubes can not dependt on other parameters! + """ + def __init__(self, space, lower_bounds, upper_bounds): + super().__init__(space=space, dim=space.dim) + self.lower_bounds = self._check_bounds(lower_bounds) + self.upper_bounds = self._check_bounds(upper_bounds) + self.shifts = self.upper_bounds - self.lower_bounds + + self.volume_tensor = torch.prod(self.shifts, dim=0, keepdim=True).unsqueeze(-1) + assert self.volume_tensor.item() > 0, "Volume of HyperCube is negative!" + + def _check_bounds(self, bound): + if isinstance(bound, (float, int)): + return torch.tensor(float(bound)).repeat(self.dim) + elif isinstance(bound, (list, tuple)): + assert len(bound) == self.dim, "Length of bounds does not fit dimension" + return torch.tensor(bound) + elif torch.is_tensor(bound): + assert len(bound.flatten()) == self.dim, "Length of bounds does not fit dimension" + return bound.flatten() + else: + raise ValueError("Type for bounds is not supported!") + + def _get_volume(self, params=Points.empty(), device="cpu"): + return self.volume_tensor.to(device) + + + def sample_random_uniform(self, n=None, d=None, params=Points.empty(), device="cpu"): + if d: n = self.compute_n_from_density(d, params) + num_of_params = self.len_of_params(params) + + points = torch.rand((num_of_params, n, self.dim), device=device) + points *= self.shifts[None, None, :] + points += self.lower_bounds[None, None, :] + return Points(points.reshape(-1, self.space.dim), self.space) + + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): + if d: n = self.compute_n_from_density(d, params) + + grid_list = [] + scale_n = torch.pow(n / self.volume_tensor, 1.0/self.dim) + for i in range(self.dim): + n_i = int(self.shifts[i] * scale_n) + 1 + grid_list.append(torch.linspace(self.lower_bounds[i], + self.upper_bounds[i], + n_i, device=device)) + + grid = torch.stack(torch.meshgrid(*grid_list)) + permute_idx = torch.flip(torch.arange(self.dim+1), dims=(0,)) + grid = torch.permute(grid, tuple(permute_idx)) + + return Points(grid.reshape(-1, self.dim)[:n], self.space) \ No newline at end of file diff --git a/src/torchphysics/problem/domains/functionsets/FE_functionset.py b/src/torchphysics/problem/domains/functionsets/FE_functionset.py deleted file mode 100644 index 604baf4e..00000000 --- a/src/torchphysics/problem/domains/functionsets/FE_functionset.py +++ /dev/null @@ -1,204 +0,0 @@ -import torch - -from ...spaces.points import Points -from .functionset import TestFunctionSet - -class FEFunctionSet(TestFunctionSet): - - def __init__(self, function_space, order, mesh_vertices, mesh_triangles=None): - super().__init__(function_space=function_space) - if len(mesh_vertices.shape) == 1: - mesh_vertices = mesh_vertices.unsqueeze(-1) - dim = len(mesh_vertices[0]) - if dim == 1 and order == 1: - self.finite_elements = LinearFE1D(mesh_vertices) - if dim == 2 and order == 1: - self.finite_elements = LinearFE2D(mesh_vertices, mesh_triangles) - else: - AssertionError(f"FE Space not implemented for dimension {dim} and order {order}.") - - - def __call__(self, x=None): - if self.finite_elements.quadrature_mode_on: - helper_out = self.eval_fn_helper.apply(x[self.function_space.input_space.variables.pop()], - self.finite_elements.basis_at_quadrature, - self.finite_elements.grad_at_quadrature) - - return Points(helper_out, self.function_space.output_space) - else: - Points(self.finite_elements(x), self.function_space.output_space) - - - def get_quad_weights(self, n): - repeats = n // len(self.finite_elements.quadrature_weights_per_dof) - return self.finite_elements.quadrature_weights_per_dof.repeat((repeats, 1, 1)) - - - def get_quadrature_points(self): - return Points(self.finite_elements.quadrature_points_per_dof, self.function_space.input_space) - - - def to(self, device): - self.finite_elements.to(device) - - - def switch_quadrature_mode_on(self, set_on : bool): - self.finite_elements.switch_quadrature_mode_on(set_on) - - -class LinearFE2D(): - - def __init__(self, mesh_vertices : torch.tensor, mesh_triangles : torch.tensor): - self.mesh_vertices = mesh_vertices - self.mesh_triangles = mesh_triangles - self.quadrature_mode_on = True - - self.dim = 2 - self.basis_dim = len(self.mesh_vertices) - - center_points, triangle_volume = self.compute_center_and_volume() - ## Next find which vertex belongs to which triangle, so we can find - ## where each basis function is not zero and construct the corresponding - ## quadrature: - vertex_to_triangle_map_h = [[] for _ in range(self.basis_dim)] - for i in range(len(self.mesh_triangles)): - for k in self.mesh_triangles[i]: - vertex_to_triangle_map_h[k].append(i) - - # Pad the mapping with -1 to save as one big tensor: - max_triangles_per_vertex = max(len(vertex_to_triangle_map_h[i]) for i in range(self.basis_dim)) - self.vertex_to_triangle_map = -1 * torch.ones((self.basis_dim, - max_triangles_per_vertex), dtype=torch.long) - for i in range(self.basis_dim): - self.vertex_to_triangle_map[i, :len(vertex_to_triangle_map_h[i])] = \ - torch.tensor(vertex_to_triangle_map_h[i]) - - - # We need basis with compact support -> no functions at the boundary: - self.find_boundary_dofs() - use_index = torch.ones(self.basis_dim, dtype=bool) - use_index[self.boundary_dofs] = False - self.quadrature_weights_per_dof = triangle_volume[self.vertex_to_triangle_map[use_index]] - self.quadrature_weights_per_dof *= (self.vertex_to_triangle_map[use_index] >= 0) - self.quadrature_weights_per_dof = self.quadrature_weights_per_dof.unsqueeze(-1) - self.quadrature_points_per_dof = center_points[self.vertex_to_triangle_map[use_index]] - self.basis_at_quadrature = torch.tensor([1.0/3.0], requires_grad=True) - - self.compute_grad_per_dof(triangle_volume, use_index, max_triangles_per_vertex) - - def switch_quadrature_mode_on(self, set_on : bool): - self.quadrature_mode_on = set_on - if not set_on: - AssertionError("Arbritrary evaluation not implemented!") - - def to(self, device): - self.quadrature_points_per_dof = self.quadrature_points_per_dof.to(device) - self.quadrature_weights_per_dof = self.quadrature_weights_per_dof.to(device) - self.basis_at_quadrature = self.basis_at_quadrature.to(device) - self.grad_at_quadrature = self.grad_at_quadrature.to(device) - - - def compute_center_and_volume(self): - ## Find center of each triangle - center_points = torch.zeros((len(self.mesh_triangles), self.dim)) - for i in range(self.dim+1): - center_points += self.mesh_vertices[self.mesh_triangles[:, i]] - center_points /= (self.dim+1) - - ## Compute volume of each triangle - vec_1 = self.mesh_vertices[self.mesh_triangles[:, 1]] \ - - self.mesh_vertices[self.mesh_triangles[:, 0]] - vec_2 = self.mesh_vertices[self.mesh_triangles[:, 2]] \ - - self.mesh_vertices[self.mesh_triangles[:, 0]] - triangle_volume = 0.5 *(vec_1[:, 0]*vec_2[:, 1] - vec_1[:, 1]*vec_2[:, 0]) - self.triangle_rot = torch.sign(triangle_volume) - triangle_volume *= self.triangle_rot - return center_points, triangle_volume - - - def find_boundary_dofs(self): - ## Not the most efficient way... - boundary_edge_list = torch.zeros((self.basis_dim, self.basis_dim), dtype=torch.int8) - for triangle in self.mesh_triangles: - v = triangle.sort()[0] - boundary_edge_list[v[0], v[1]] += 1 - boundary_edge_list[v[0], v[2]] += 1 - boundary_edge_list[v[1], v[2]] += 1 - self.boundary_dofs = torch.unique(torch.cat(torch.where(boundary_edge_list == 1))) - - - def compute_grad_per_dof(self, triangle_volume, inner_dofs, max_triangles_per_vertex): - inner_idx = torch.where(inner_dofs)[0] - self.grad_at_quadrature = torch.zeros((len(inner_idx), max_triangles_per_vertex, 2)) - for c, i in enumerate(inner_idx): - for j, k in enumerate(self.vertex_to_triangle_map[i]): - if k == -1: # -1 mapping means not further triangles are neighbours - break - remove_i = (self.mesh_triangles[k] != i) - neighbour_dofs = self.mesh_triangles[k][remove_i] - edge_vec = self.mesh_vertices[neighbour_dofs[1]] - self.mesh_vertices[neighbour_dofs[0]] - if not remove_i[1]: - # if we removed the second vertex from the triangle, we need to multiple - # by -1 to fix the direction of the edge - edge_vec *= -1 - edge_vec = torch.tensor([-edge_vec[1], edge_vec[0]]) # rotate - edge_vec /= (2*triangle_volume[k]) - self.grad_at_quadrature[c, j, :] = self.triangle_rot[k] * edge_vec - - def __call__(self, x): - pass - - -class LinearFE1D(): - - def __init__(self, mesh_vertices : torch.tensor): - self.mesh_vertices, _ = torch.sort(mesh_vertices) - self.quadrature_mode_on = True # if evaluation only happens at all quadrature points - - self.dim = 1 - self.basis_dim = len(self.mesh_vertices) - - center_points, interval_length = self.compute_center_and_volume() - - - # We need basis with compact support -> no functions at the boundary: - self.quadrature_weights_per_dof = torch.column_stack((interval_length[:-1], interval_length[1:])) - self.quadrature_weights_per_dof = self.quadrature_weights_per_dof.unsqueeze(-1) - - self.quadrature_points_per_dof = torch.column_stack((center_points[:-1], center_points[1:])) - self.quadrature_points_per_dof = self.quadrature_points_per_dof.unsqueeze(-1) - self.basis_at_quadrature = torch.tensor([1.0/2.0]) - - self.compute_grad_per_dof(interval_length) - - - def switch_quadrature_mode_on(self, set_on : bool): - self.quadrature_mode_on = set_on - if not set_on: - AssertionError("Arbritrary evaluation not implemented!") - - - def to(self, device): - self.quadrature_points_per_dof = self.quadrature_points_per_dof.to(device) - self.quadrature_weights_per_dof = self.quadrature_weights_per_dof.to(device) - self.basis_at_quadrature = self.basis_at_quadrature.to(device) - self.grad_at_quadrature = self.grad_at_quadrature.to(device) - - - def compute_center_and_volume(self): - ## Find center of each triangle - center_points = self.mesh_vertices[:-1] + self.mesh_vertices[1:] - center_points /= 2.0 - - interval_length = self.mesh_vertices[:-1] - self.mesh_vertices[1:] - return center_points, interval_length - - - def compute_grad_per_dof(self, interval_length): - self.grad_at_quadrature = torch.zeros((self.basis_dim - 2, 2, 1)) - self.grad_at_quadrature[:, :1, 0] = 1.0/interval_length[:-1] - self.grad_at_quadrature[:, 1:, 0] = -1.0/interval_length[:-1] - - - def __call__(self, x): - pass \ No newline at end of file diff --git a/src/torchphysics/problem/domains/functionsets/__init__.py b/src/torchphysics/problem/domains/functionsets/__init__.py index 52008f00..d717bfeb 100644 --- a/src/torchphysics/problem/domains/functionsets/__init__.py +++ b/src/torchphysics/problem/domains/functionsets/__init__.py @@ -2,4 +2,8 @@ Function sets can be used to sample functions, e.g. in DeepONet. """ -from .functionset import FunctionSet, CustomFunctionSet +from .functionset import FunctionSet, DiscreteFunctionSet#, FunctionSetCollection, FunctionSetUnion +from .custom_functionset import CustomFunctionSet +from .harmonic_functionset import (HarmonicFunctionSet1D, + HarmonicFunctionSet2D, + HarmonicFunctionSet3D) diff --git a/src/torchphysics/problem/domains/functionsets/custom_functionset.py b/src/torchphysics/problem/domains/functionsets/custom_functionset.py new file mode 100644 index 00000000..34b0e8e0 --- /dev/null +++ b/src/torchphysics/problem/domains/functionsets/custom_functionset.py @@ -0,0 +1,61 @@ +import torch + +from .functionset import FunctionSet + +from ....utils.user_fun import UserFunction +from ...samplers import PointSampler +from ...spaces import Points + + +class CustomFunctionSet(FunctionSet): + """FunctionSet for an arbitrary function. + + Parameters + ---------- + parameter_sampler : torchphysics.samplers.PointSampler + A sampler that provides additional parameters that can be used + to create different kinds of functions. E.g. our FunctionSet consists + of Functions like k*x, x is the input variable and k is given through + the sampler. + + During each training iteration will call the parameter_sampler to sample + new parameters. For each parameter a function will be created and the + input batch of functions will be of the same length as the sampled + parameters. + custom_fn : callable + A function that describes the FunctionSet. The input of the functions + can include the variables of the function_space.input_space and the + parameters from the parameter_sampler. + """ + + def __init__(self, function_space, parameter_sampler : PointSampler, custom_fn): + super().__init__(function_space=function_space, function_set_size=parameter_sampler.n_points) + + if not isinstance(custom_fn, UserFunction): + custom_fn = UserFunction(custom_fn) + + self.custom_fn = custom_fn + self.parameter_sampler = parameter_sampler + + def create_functions(self, device="cpu"): + self.param_samples = self.parameter_sampler.sample_points(device=device) + + def get_function(self, idx): + if isinstance(idx, int): idx = [idx] + self.current_idx = idx + return self._evaluate_fn_at_locations + + def _evaluate_fn_at_locations(self, locations : Points): + # TODO: Not so nice for memory usage, can this be improved??? + location_copy = self._transform_locations(locations) + + params_copy = torch.repeat_interleave( + self.param_samples.as_tensor[self.current_idx].unsqueeze(1), + location_copy.shape[1], dim=1 + ) + + fn_input = torch.cat([location_copy, params_copy], dim=-1) + fn_output = self.custom_fn( + Points(fn_input, self.function_space.input_space*self.param_samples.space) + ) + return Points(fn_output, self.function_space.output_space) diff --git a/src/torchphysics/problem/domains/functionsets/data_functionset.py b/src/torchphysics/problem/domains/functionsets/data_functionset.py new file mode 100644 index 00000000..0b99bdc0 --- /dev/null +++ b/src/torchphysics/problem/domains/functionsets/data_functionset.py @@ -0,0 +1,41 @@ +import torch + +from .functionset import DiscreteFunctionSet +from ...spaces import Points + + +class DataFunctionSet(DiscreteFunctionSet): + """FunctionSet that is created from a given data set. + This function set is always a discret set, since the data can not + be evaluated at arbitrary points. + + Parameters + ---------- + function_space : tp.spaces.FunctionSpace + The function space of the functions in the set. + data : torch.Tensor + The data that describes the function values. The shape of the last + dimension has to match the dimension of the output space. + """ + def __init__(self, function_space, data): + assert data.shape[-1] == function_space.output_space.dim + super().__init__(function_space, len(data), data.shape[1:-1]) + self.data = data + + def create_functions(self, device="cpu"): + self.data = self.data.to(device) + + def get_function(self, idx): + return Points(self.data[idx], self.function_space.output_space) + + def compute_normalization(self): + self.mean_tensor = torch.mean(self.data, dim=0, keepdim=True) + self.std_tensor = torch.std(self.data, dim=0, keepdim=True) + + def compute_pca(self, components, normalize_data = True): + data_copy = self.data + if normalize_data: + data_copy = (self.data - self.mean) / self.std + + self.pca = torch.pca_lowrank(torch.flatten(data_copy, 1), + q=components) \ No newline at end of file diff --git a/src/torchphysics/problem/domains/functionsets/functionset.py b/src/torchphysics/problem/domains/functionsets/functionset.py index 27b4d767..e622f25b 100644 --- a/src/torchphysics/problem/domains/functionsets/functionset.py +++ b/src/torchphysics/problem/domains/functionsets/functionset.py @@ -1,236 +1,384 @@ import abc import torch -from ...spaces.points import Points -from ....utils.user_fun import UserFunction -from ...spaces.functionspace import FunctionSpace +integer_dtypes = [torch.uint8, torch.int8, torch.int16, torch.int32, torch.int, torch.int64, torch.long] -class FunctionSet: - """A set of functions that can supply samples from a function space. +class FunctionSet(): + """ A function set describes a specfic type of functions that can be used + for creating data for training different operator approaches. Parameters ---------- - function_space : torchphysics.spaces.FunctionSpace - The space of which this set of functions belongs to. The inputs and outputs - of this FunctionSet are defined by the corresponding values inside the function - space. - parameter_sampler : torchphysics.samplers.PointSampler - A sampler that provides additional parameters that can be used - to create different kinds of functions. E.g. our FunctionSet consists - of Functions like k*x, x is the input variable and k is given through - the sampler. - - During each training iteration will call the parameter_sampler to sample - new parameters. For each parameter a function will be created and the - input batch of functions will be of the same length as the sampled - parameters. + function_space : tp.spaces.FunctionSpace + The function space that the functions in the set should be part of. + This defines what input and output space the functions have. + function_set_size : int + An integer that defines how many functions are stored in the set. + This is used for creating multiple functions at once and + then storing them for later use. + + Notes + ----- + The `function_set_size` is motivated by the case that creating functions + (either by computations or loading from disk) can be computationally + expensive if done for each function individually. Therefore, we aim + to create multiple functions at once and then store them. When + later functions are sampled from this set, they can be quickly returned. + But this creation is not only done once but can be repeated after + some time to obtain new functions. """ - - def __init__(self, function_space, parameter_sampler): - assert isinstance( - function_space, FunctionSpace - ), """A FunctionSet needs a torchphysics.spaces.FunctionSpace!""" + def __init__(self, function_space, function_set_size): self.function_space = function_space - self.parameter_sampler = parameter_sampler - self.param_batch = None - self.current_iteration_num = -1 - - def __add__(self, other): - """Combines two function sets. + self.function_set_size = function_set_size + + @property + def is_discretized(self): + """ Returns if the function set is already discretized. + """ + return False + + def is_discretization_of(self, function_set): + """ Returns if the function set is the discretization of another + function set. - Notes - ----- - When parameters are sampled, will sample them from both sets. - Creates a batch of functions consisting of the batch of each set. - (Length of the batches will be added) + Parameters + ---------- + function_set : tp.domains.FunctionSet + The other function set we should compare with. """ - assert ( - other.function_space == self.function_space - ), """Both FunctionSets do not have the same FunctionSpace!""" - if isinstance(other, FunctionSetCollection): - return other + self - else: - return FunctionSetCollection([self, other]) + return False + + @abc.abstractmethod + def create_functions(self, device="cpu"): + """ Creates the functions for the function set and stores them. + The created functions can then be retrieved by the `get_function` method. - def __len__(self): - """Returns the amount of functions sampled in a single call to sample_params.""" - return len(self.parameter_sampler) + Parameters + ---------- + device : str + The device on which the functions should be stored. + """ + raise NotImplementedError - def sample_params(self, device="cpu"): - """Samples parameters of the function space. + @abc.abstractmethod + def get_function(self, idx): + """ Returns a function from the function set. Parameters ---------- - device : str, optional - The device, where the parameters should be created. Default is 'cpu'. + idx : int or list, tensor of int + The index of the function that should be returned. + Multiple functions can be returned at once when a list or tensor + is passed in. Note that the index should be in the range of the function + set size. - Notes - ----- - We save the sampled parameters internally, so that we can use them multiple times. - Since given a parameter we still have a continuous representation of the underlying - function types. When the functions should be evaluated at some input points, - we just have to create the meshgrid of parameters and points. + Returns + ------- + callable or torch.tensor + Returns the function. If the function set is discrete, the functions + can not be further evaluated and are therefore returned as a tensor. Otherwise + a callable is returned that can be evaluated at any point. """ - self.param_batch = self.parameter_sampler.sample_points(device=device) - - def create_function_batch(self, points): - """Evaluates the underlying function object to create a batch of - discrete function samples. + raise NotImplementedError + + def discretize(self, locations): + """ Discretizes the function set, to be always evaluated at the + provided locations. Parameters ---------- - points : torchphysics.spaces.Points - The input points, where we want to evaluate a set of functions. + locations : tp.spaces.Points + The points at which the functions should be evaluated. Returns ------- - torchphysics.spaces.Points - The batch of discrete function samples. The underlying tensor is of the - shape: [len(self), len(points), self.function_space.output_space.dim] + tp.domains.DiscretizedFunctionSet + The discretized function set. """ - param_point_meshgrid = self._create_meshgrid(points) - output = self._evaluate_function(param_point_meshgrid) - return Points(output, self.function_space.output_space) + assert len(locations.as_tensor.shape) >= 3, \ + f"""Locations for discretization need a shape >= 3 to be compatible with all implemented + methods. The provided shape is only of length {len(locations.as_tensor.shape)}. + Apply .unsqueeze(0) to the data to add one additional batch dimension.""" + return DiscretizedFunctionSet(self, locations) - def _create_meshgrid(self, points): - """Creates the meshgrid of current batch parameter and discretization - points. - """ - n_points = len(points) - n_params = len(self.param_batch) - points_repeated = points.as_tensor.unsqueeze(0).repeat(n_params, 1, 1) - params_repeated = self.param_batch.as_tensor.unsqueeze(1).repeat(1, n_points, 1) - param_point_meshgrid = Points( - torch.cat((params_repeated, points_repeated), dim=-1), - self.param_batch.space * points.space, - ) - return param_point_meshgrid + def __mul__(self, other): + """ Creates a product of two function sets. Leading to a product in the + function spaces and the function outputs are concatenated along the output + dimension. - @abc.abstractmethod - def _evaluate_function(self, param_point_meshgrid): - """Here the underlying functions of the FunctionSet will be evaluated.""" - raise NotImplementedError + Parameters + ---------- + The other function set that should be multiplied with this one. + Returns + ------- + tp.domains.FunctionSetProduct + The product of the two function sets. + """ + from .functionset_operations import FunctionSetProduct + + assert self.function_space.output_space != other.function_space.output_space, \ + """Both FunctionSets have the same output space, maybe you want to use 'append' instead?""" + + if isinstance(other, FunctionSetProduct): + return other * self + if other.is_discretized and not self.is_discretized: + return other * self + else: + assert self.function_set_size == other.function_set_size, \ + """Both FunctionSets need the same size!""" + return FunctionSetProduct(self.function_space*other.function_space, [self, other]) -class FunctionSetCollection(FunctionSet): - """Collection of multiple FunctionSets. Used for the additions of - different FunctionSets. + def append(self, other): + """ Stacks two function sets together, such that different kind of functions + can be combined into one set. - Parameters - ---------- - function_sets : list, tuple - A list/tuple of FunctionSets. - """ + Parameters + ---------- + The other function set that should be connected with this one. - def __init__(self, function_sets): - self.collection = function_sets - super().__init__( - function_space=function_sets[0].function_space, parameter_sampler=None - ) + Returns + ------- + tp.domains.FunctionSetCollection + The collection of the two function sets. + """ + from .functionset_operations import FunctionSetCollection - def __add__(self, other): - assert ( - other.function_space == self.function_space - ), """Both FunctionSets do not have the same FunctionSpace!""" + assert self.function_space.output_space == other.function_space.output_space, \ + """Both FunctionSets need the same output space!""" if isinstance(other, FunctionSetCollection): - self.collection += other.collection + return other * self else: - self.collection.append(other) - return self - - def __len__(self): - return sum(len(f_s) for f_s in self.collection) + return FunctionSetCollection(self.function_space, [self, other]) - def sample_params(self, device="cpu"): - for function_set in self.collection: - function_set.sample_params(device) + def __add__(self, other): + """ Performs the "pointwise" addition of two function sets. - def create_function_batch(self, points): - output = Points.empty() - for function_set in self.collection: - output = output | function_set.create_function_batch(points) - return output + Parameters + ---------- + The other function set that should be added to this one. + Returns + ------- + tp.domains.FunctionSetAdd + The function sets that computes the sum of the inputs. + """ + from .functionset_operations import FunctionSetAdd -class CustomFunctionSet(FunctionSet): - """FunctionSet for an arbitrary function. + if isinstance(other, FunctionSetAdd): + return other + self + else: + return FunctionSetAdd(self.function_space, [self, other]) - Parameters - ---------- - function_space : torchphysics.spaces.FunctionSpace - The space of which this set of functions belongs to. The inputs and outputs - of this FunctionSet are defined by the corresponding values inside the function - space. - parameter_sampler : torchphysics.samplers.PointSampler - A sampler that provides additional parameters that can be used - to create different kinds of functions. E.g. our FunctionSet consists - of Functions like k*x, x is the input variable and k is given through - the sampler. - - During each training iteration will call the parameter_sampler to sample - new parameters. For each parameter a function will be created and the - input batch of functions will be of the same length as the sampled - parameters. - custom_fn : callable - A function that describes the FunctionSet. The input of the functions - can include the variables of the function_space.input_space and the - parameters from the parameter_sampler. - """ + def __sub__(self, other): + """ Performs the "pointwise" substraction of two function sets. - def __init__(self, function_space, parameter_sampler, custom_fn): - super().__init__( - function_space=function_space, parameter_sampler=parameter_sampler - ) - if not isinstance(custom_fn, UserFunction): - custom_fn = UserFunction(custom_fn) - self.custom_fn = custom_fn + Parameters + ---------- + The other function set that should be substracted from this one. - def _evaluate_function(self, param_point_meshgrid): - return self.custom_fn(param_point_meshgrid) + Returns + ------- + tp.domains.FunctionSetSubstract + The function sets that computes the difference of the inputs. + """ + from .functionset_operations import FunctionSetSubstract + return FunctionSetSubstract(self.function_space, [self, other]) + + def _transform_locations(self, locations): + # TODO: Improve this for general location shapes + if len(locations.shape) == 1: + locations = locations.unsqueeze(0) + + if locations.as_tensor.shape[0] == 1: + location_copy = torch.repeat_interleave( + locations[self.function_space.input_space].as_tensor, + len(self.current_idx), dim=0 + ) + else: + location_copy = locations[self.function_space.input_space].as_tensor[:len(self.current_idx)] + return location_copy +class DiscreteFunctionSet(FunctionSet): + """ A function set that only returns already discretized functions, which + can not be evaluated at arbitrary locations. + """ + def __init__(self, function_space, function_set_size, data_shape): + super().__init__(function_space, function_set_size) + self.data_shape = data_shape + self.pca = None + self.mean_tensor = None + self.std_tensor = None + + @property + def is_discretized(self): + return True + + def discretize(self, locations): + assert torch.is_tensor(locations) + assert locations.dtype in integer_dtypes, \ + """A discrete FunctionSet can only be further discretized by passing in indices + to subsample the current discretization.""" + return DiscretizedFunctionSet(self, locations) + + def compute_pca(self, + components : int, + normalize_data : bool = True, + ): + """ Carries out the principal component analysis for this function set. -class TestFunctionHelper(torch.autograd.Function): + Parameters + ---------- + components : int + The number of components that should be keeped in the PCA. + normalize_data : bool, optional + If the data of the function set should be normalized before the + PCA is computed (recommented). Default is true. + Note, the normalization is only applied during this method and + not saved afterwards, therefore the underlying data in this function + set is **not** modified! + + Notes + ----- + The PCA is not returned but instead saved internally for later + usage. Use '.principal_components' to obtain the PCA. - @staticmethod - def forward(ctx, x, expected_out, grad_out): - ctx.save_for_backward(grad_out) - x_ten = torch.sum(x, dim=-1, keepdim=True) - return expected_out + 0.0 * x_ten# <- hack to build graph to allow for precomputed gradient + Also the data of the function set is flattened over all dimensions expect + of the batch dimension. For higher dimensional data (e.g. images) other + approaches (like localized PCAs on small patches) may be better suited. + """ + pass - @staticmethod - def backward(ctx, grad_output): - grad_out, = ctx.saved_tensors - repeats = grad_output.shape[0] // grad_out.shape[0] - # Assumes the original data to be repeated along the first axis - # TODO: Can be done nicer??? - return grad_out.repeat((repeats, 1, 1)) * grad_output, None, None + @property + def principal_components(self): + """ Returns the principal components of this function set. + It is requiered to first call 'compute_pca' to compute them and set + a number n of the used components. + Returns + ------- + list : + A list of the principal components in the shape of (U, S, V). + - U is the matrix of the left singular vectors of shape + (function_set_size, n) + - S is a vector containing the first n eigen values of the + covariance matrix. + - V is the matrix of the principal directions of shape + (function_set_dimension, n) + See also: https://pytorch.org/docs/stable/generated/torch.pca_lowrank.html + """ + if self.pca is None: + raise AssertionError("PCA needs to be computed! Use the method 'compute_pca'.") + return self.pca + + @property + def mean(self): + if self.mean_tensor is None: self.compute_normalization() + return self.mean_tensor + + @property + def std(self): + if self.std_tensor is None: self.compute_normalization() + tol = 0.0001 # (add small value to std in case it is zero, + # can happen if we have some constant data (Dirichlet condition on boundary)) + return self.std_tensor + tol + + def compute_normalization(self): + """ Computes the mean and standard deviation over the data contained in this + function set. + + Notes + ----- + The values are not returned but stored internally. + Use '.mean' and '.std' to obtain them. + """ + pass -class TestFunctionSet(FunctionSet): - def __init__(self, function_space): - super().__init__(function_space=function_space, parameter_sampler=None) - self.eval_fn_helper = TestFunctionHelper() - self.quadrature_mode_on = True - @abc.abstractmethod - def switch_quadrature_mode_on(self, set_on : bool): - raise NotImplementedError +class DiscretizedFunctionSet(DiscreteFunctionSet): + """ A discretized function set that is always evaluated at the provided locations. - @abc.abstractmethod - def __call__(self, x): - raise NotImplementedError + Parameters + ---------- + function_set : tp.domains.FunctionSet + The function set that should be discretized. + locations : tp.spaces.Points or torch.tensor + The points at which the functions should be evaluated. + """ + def __init__(self, function_set : FunctionSet, locations): + if torch.is_tensor(locations): + data_shape = locations.shape[:-1] # dimension of input points not needed + else: + data_shape = locations.shape + + super().__init__(function_set.function_space, + function_set.function_set_size, + data_shape) + + self.function_set = function_set + self.locations = locations + if self.function_set.is_discretized: + assert self.locations.dtype in integer_dtypes - @abc.abstractmethod - def to(self, device): - raise NotImplementedError + def is_discretization_of(self, function_set): + return (self.function_set is function_set) or (self.function_set.is_discretization_of(function_set)) - @abc.abstractmethod - def get_quad_weights(self, n): - raise NotImplementedError - - @abc.abstractmethod - def get_quadrature_points(self): - raise NotImplementedError \ No newline at end of file + def create_functions(self, device="cpu"): + self.locations = self.locations.to(device) + self.function_set.create_functions(device) + + def get_function(self, idx): + samples = self.function_set.get_function(idx) + if callable(samples): + return samples(self.locations) + else: + # we assume that self.locations is a grid, and its last dimension corresponds + # to the amount of grid axis. i.e. + assert (len(samples.shape) - 2) == self.locations.shape[-1] + out_shape = (samples.shape[0], *self.locations.shape[0:-1], samples.shape[-1]) + locations_slice = torch.unbind(torch.reshape(self.locations, + (-1, self.locations.shape[-1])), + dim=-1) + locations_slice = (slice(None), *locations_slice, slice(None)) + return samples[locations_slice].reshape(*out_shape) + + def compute_normalization(self): + all_fns = self.get_function( + torch.arange(0, self.function_set_size, device=self.locations.device)).as_tensor + self.mean_tensor = torch.mean(all_fns, dim=0, keepdim=True) + self.std_tensor = torch.std(all_fns, dim=0, keepdim=True) + + + def compute_pca(self, components, normalize_data = True): + data_copy = self.get_function( + torch.arange(0, self.function_set_size, device=self.locations.device)).as_tensor + + if normalize_data: + data_copy = (data_copy- self.mean) / self.std + + self.pca = torch.pca_lowrank(torch.flatten(data_copy, 1), + q=components) + + + def __mul__(self, other): + from .functionset_operations import FunctionSetProduct + + assert self.function_space.output_space != other.function_space.output_space, \ + """Both FunctionSets have the same output space, maybe you want to use 'append' instead?""" + assert self.function_set_size == other.function_set_size, \ + """Both FunctionSets need the same size!""" + + if isinstance(other, FunctionSetProduct): + return other * self + if other.is_discretized: + assert torch.equal(self.locations, other.locations), \ + """Both DiscretizedFunctionSets need the same locations for creating the product!""" + return FunctionSetProduct(self.function_space*other.function_space, [self, other]) + else: + Warning(f"""DiscretizedFunctionSet is multiplied with a continuous FunctionSet. + The continuous FunctionSet will be discrtized to create the product.""") + other_discrete = other.discretize(self.locations) + return FunctionSetProduct(self.function_space*other.function_space, [self, other_discrete]) diff --git a/src/torchphysics/problem/domains/functionsets/functionset_operations.py b/src/torchphysics/problem/domains/functionsets/functionset_operations.py new file mode 100644 index 00000000..7a3db77e --- /dev/null +++ b/src/torchphysics/problem/domains/functionsets/functionset_operations.py @@ -0,0 +1,311 @@ +import torch +import abc + +from ...spaces.points import Points +from .functionset import FunctionSet, DiscretizedFunctionSet +from ....utils.user_fun import UserFunction + + +class FunctionSetProduct(FunctionSet): + """The product of multiple function sets. + + Parameters + ---------- + function_space : tp.spaces.FunctionSpace + The function space of the set. + function_sets : list + A list of FunctionSets that should be multiplied together. + """ + def __init__(self, function_space, function_sets): + super().__init__(function_space, function_sets[0].function_set_size) + self.function_sets = function_sets + + @property + def is_discretized(self): + return self.function_sets[0].is_discretized + + def __mul__(self, other): + assert self.function_space.output_space != other.function_space.output_space, \ + """Both FunctionSets have the same output space, maybe you want to use 'append' instead?""" + assert self.function_set_size == other.function_set_size, \ + """Both FunctionSets need the same size!""" + + if isinstance(other, DiscretizedFunctionSet): + if not self.is_discretized: + raise ValueError("Other FunctionSet is discrete but this set is continuous.") + else: + assert torch.equal(self.function_sets[0].locations, other.locations), \ + """Both DiscretizedFunctionSets need the same locations for creating the product!""" + return FunctionSetProduct(self.function_space*other.function_space, + self.function_sets + [other]) + elif isinstance(other, FunctionSetProduct): + return FunctionSetProduct(self.function_space*other.function_space, + self.function_sets + other.function_sets) + else: + return FunctionSetProduct(self.function_space*other.function_space, + self.function_sets + [other]) + + def is_discretization_of(self, function_set): + if isinstance(function_set, FunctionSetProduct): + for self_set in self.function_sets: + for other_set in function_set.function_sets: + if self_set.is_discretization_of(other_set): + break + else: + return False + return True + # Can not be a discretization of a non-product function set + return False + + def create_functions(self, device="cpu"): + for fn_set in self.function_sets: + fn_set.create_functions(device) + + def get_function(self, idx): + if self.is_discretized: + point_list = [fn_set.get_function(idx) for fn_set in self.function_sets] + return Points.joined(*point_list) + else: + self.fn_list = [fn_set.get_function(idx) for fn_set in self.function_sets] + return self._evaluate_product + + def discretize(self, locations): + return FunctionSetProduct(self.function_space, + [f.discretize(locations) for f in self.function_sets]) + + + def _evaluate_product(self, locations): + point_list = [fn(locations) for fn in self.fn_list] + return Points.joined(*point_list) + + +class FunctionSetCollection(FunctionSet): + """Collection of multiple FunctionSets. Used for combining different kinds of + functions into one single set. + + Parameters + ---------- + function_space : tp.spaces.FunctionSpace + The function space of the set. + function_sets : list + A list of FunctionSets that should be combined. + """ + def __init__(self, function_space, function_sets): + set_size = 0 + for fn_set in function_sets: + set_size += fn_set.function_set_size + + super().__init__(function_space, set_size) + + self.function_sets = function_sets + self.current_idx = [] + self.device = "cpu" + + @property + def is_discretized(self): + for fn_set in self.function_sets: + if fn_set.is_discretized: + return True + return False + + def is_discretization_of(self, function_set): + if isinstance(function_set, FunctionSetCollection): + for self_set in self.function_sets: + for other_set in function_set.function_sets: + if self_set.is_discretization_of(other_set): + break + else: + return False + return True + return False + + def create_functions(self, device="cpu"): + for fn_set in self.function_sets: + fn_set.create_functions(device) + self.device = device + + def get_function(self, idx): + if isinstance(idx, int): idx = [idx] + self.current_idx = torch.tensor(idx, dtype=torch.long, device=self.device) + return self._evaluate_collection + + def _evaluate_collection(self, location : Points): + # We go over each function set of the collection and check + # if the given indices belong to this set to sample functions there. + final_output = [] + # we may need to fix the order at the end such that the input index + # also fits the output values + idx_permut = [] + size_counter = 0 + for fn_set in self.function_sets: + valid_idx = torch.where( + (self.current_idx >= size_counter) & (self.current_idx < size_counter + fn_set.function_set_size) + )[0] + if len(valid_idx) > 0: + fn_set_idx = self.current_idx[valid_idx] + fn_set_idx -= size_counter # shift index back to start at zero + fn_set_output = fn_set.get_function(fn_set_idx)(location).as_tensor + if len(final_output) == 0: + final_output = fn_set_output + idx_permut = valid_idx + else: + final_output = torch.cat((final_output, fn_set_output), dim=0) + idx_permut = torch.cat((idx_permut, valid_idx)) + + size_counter += fn_set.function_set_size + + final_output = final_output[idx_permut] + return Points(final_output, self.function_space.output_space) + + def discretize(self, locations): + return FunctionSetCollection(self.function_space, + [f.discretize(locations) for f in self.function_sets]) + + def append(self, other): + assert self.function_space.output_space == other.function_space.output_space, \ + """Both FunctionSets need the same output space!""" + if isinstance(other, FunctionSetCollection): + return FunctionSetCollection(self.function_space, + self.function_sets + other.function_sets) + else: + return FunctionSetCollection(self.function_space, + self.function_sets + [other]) + + +class FunctionSetArithmetics(FunctionSet): + + def __init__(self, function_space, function_sets): + for i in range(len(function_sets)): + assert function_sets[0].function_set_size == function_sets[i].function_set_size, \ + "Size of function sets is not the same, you can not combine them!" + assert function_sets[0].is_discretized == function_sets[i].is_discretized, \ + "Some function sets are discretized some are not, you can not combine them!" + + super().__init__(function_space, function_sets[0].function_set_size) + + self.function_sets = function_sets + self.current_idx = [] + + @property + def is_discretized(self): + return self.function_sets[0].is_discretized + + def is_discretization_of(self, function_set): + if isinstance(function_set, FunctionSetArithmetics): + for self_set in self.function_sets: + for other_set in function_set.function_sets: + if self_set.is_discretization_of(other_set): + break + else: + return False + return True + return False + + def create_functions(self, device="cpu"): + for fn_set in self.function_sets: + fn_set.create_functions(device) + + def get_function(self, idx): + if self.is_discretized: + data_list = [fn_set.get_function(idx).as_tensor for fn_set in self.function_sets] + return self.arithmetic_function(data_list) + else: + self.fn_list = [fn_set.get_function(idx) for fn_set in self.function_sets] + return self._evaluate_product + + def _evaluate_product(self, locations): + data_list = [fn(locations).as_tensor for fn in self.fn_list] + return self.arithmetic_function(data_list) + + @abc.abstractmethod + def arithmetic_function(self, data): + raise NotImplementedError + + @abc.abstractmethod + def discretize(self, locations): + raise NotImplementedError + + +class FunctionSetAdd(FunctionSetArithmetics): + """ + A class handling the pointwise addition of two sets. + """ + def arithmetic_function(self, data): + output = torch.zeros_like(data[0]) + for i in range(len(data)): + output += data[i] + return Points(output, self.function_space.output_space) + + def discretize(self, locations): + return FunctionSetAdd(self.function_space, + [f.discretize(locations) for f in self.function_sets]) + + def __add__(self, other): + if isinstance(other, FunctionSetAdd): + return FunctionSetAdd(self.function_space, + self.function_sets + other.function_sets) + else: + return FunctionSetAdd(self.function_space, + self.function_sets + [other]) + + +class FunctionSetSubstract(FunctionSetArithmetics): + """ + A class handling the pointwise substraction of two sets. + """ + def arithmetic_function(self, data): + # data will be always only two different function sets + output = data[1] - data[0] + return Points(output, self.function_space.output_space) + + def discretize(self, locations): + return FunctionSetSubstract(self.function_space, + [f.discretize(locations) for f in self.function_sets]) + + +class FunctionSetTransform(FunctionSet): + """A class that acts as a wrapper of a different function set to further modify + the created functions. E.g., clamping the values produced by a different + function set. + + Parameters + ---------- + function_set : tp.domains.FunctionSet + The function set that should be transformed. + transformation : callable + The function that carries out the transformation. This transformation will + be carried out "pointwise". + + """ + def __init__(self, function_set : FunctionSet, transformation): + self.fn_set = function_set + self.transformation = UserFunction(transformation) + super().__init__(self.fn_set.function_space, self.fn_set.function_set_size) + + @property + def is_discretized(self): + return self.fn_set.is_discretized + + def is_discretization_of(self, function_set): + if isinstance(function_set, FunctionSetTransform): + return self.fn_set.is_discretization_of(function_set.fn_set) + else: + return self.fn_set.is_discretization_of(function_set) + + def create_functions(self, device="cpu"): + self.fn_set.create_functions(device=device) + + def get_function(self, idx): + if self.fn_set.is_discretized: + transformed_pnt = self.transformation(self.fn_set.get_function(idx)) + return Points(transformed_pnt, self.function_space.output_space) + else: + self.fn_set_eval = self.fn_set.get_function(idx) + return self._eval_fn_set + + def _eval_fn_set(self, locations): + transformed_pnt = self.transformation(self.fn_set_eval(locations)) + return Points(transformed_pnt, self.function_space.output_space) + + def discretize(self, locations): + return FunctionSetTransform(self.fn_set.discretize(locations), self.transformation) \ No newline at end of file diff --git a/src/torchphysics/problem/domains/functionsets/grf_functionset.py b/src/torchphysics/problem/domains/functionsets/grf_functionset.py new file mode 100644 index 00000000..ec8d5663 --- /dev/null +++ b/src/torchphysics/problem/domains/functionsets/grf_functionset.py @@ -0,0 +1,118 @@ +import torch +from itertools import product + +from .functionset import DiscreteFunctionSet +from ...spaces import Points + + +class GRFFunctionSet(DiscreteFunctionSet): + """A functionset that creates Gaussian Random Fields (GRF). + + Parameters + ---------- + resolution : int, tuple, list + The resolution of the gausian random field. For higher dimensional + fields a tuple or list must be passed in setting the resoultion + for each dimension. Each resolution needs to be even. + auto_cov_fn : callable, optional + The function describing the correlation between the points in the + gaussian random field. + Is evaluated in the fourier space at the frequencies + (k_i - resolution_i/2) for i = 1, …, dimension + and k_i = 0,…, resolution_i. + Default is a power law given by + lambda x : 1/(1 + sum([i**2 for i in x]))**2 + random_generator_fn : callable, optional + A function that creates the underlying random variables. + As an input obtains a tuple of the shape + (number of functions, resolution_1, …, resolution_n) + and also the keyword argument device. + Should output random values in the corresponding shape on the given + device (cpu, gpu, etc.) as a PyTorch tensor. + Default is torch.randn, a normal distribution with variance 1. + normalize : bool, optional + Normalizes the GRF such that it has mean zero and standard deviation 1.0. + Default is True. + sample_noise_in_fourier_space : bool, optional + If we can sample the noise directly in the fourier space, so the + random_generator_fn is called two times and the noise is constructed + as the sum of both function calls, where one output is multiplied by the + imaginary unit. Else we will sample the noise and then transfer the data + to the fourier space with a fft. + Default is True. + flatten : bool, optional + If the output should be flattened to a 1D tensor along all intermediate dimensions. + Default is False. + """ + def __init__(self, function_space, function_set_size, resolution, + auto_cov_fn : callable = lambda x : 1/(1 + sum([i**2 for i in x]))**2, + random_generator_fn : callable = torch.randn, + normalize : bool = True, + sample_noise_in_fourier_space : bool = True, + flatten : bool = False): + if isinstance(resolution, int): resolution = [resolution] + assert function_space.input_space.dim == len(resolution), \ + "Resolution shape does not match input space dimension." + + super().__init__(function_space, function_set_size, resolution) + + self.cov_matrix = torch.zeros(resolution) + for x in product(*(range(-r//2, r//2) for r in resolution)): + y = [x[i] + resolution[i]//2 for i in range(len(x))] + self.cov_matrix[tuple(y)] = auto_cov_fn(x) + + self.normalize = normalize + self.shift_idx = [i+1 for i in range(len(resolution))] + self.random_gen_fn = random_generator_fn + self.sample_in_fourier_space = sample_noise_in_fourier_space + self.flatten = flatten + self.grf = None + + def create_functions(self, device="cpu"): + self.cov_matrix = self.cov_matrix.to(device) + sample_shape = (self.function_set_size, ) + self.cov_matrix.shape + # 1) sample the underlying noise + if self.sample_in_fourier_space: + noise = self.random_gen_fn(sample_shape, device=device) + noise2 = self.random_gen_fn(sample_shape, device=device) + noise = torch.complex(noise, noise2) + else: + noise = self.random_gen_fn(sample_shape, device=device) + noise = torch.fft.fftn(noise, dim=len(sample_shape)-1) + noise = torch.fft.fftshift(noise, dim=self.shift_idx) + + # 2) multiply by cov matrix and go back from fourier space + field = torch.fft.ifftshift(self.cov_matrix * noise, dim=self.shift_idx) + field = torch.fft.ifftn(field, dim=self.shift_idx).real + + if self.normalize: + mean_values = torch.mean(field, dim=self.shift_idx, keepdim=True) + field -= mean_values + std_values = torch.std(field, dim=self.shift_idx, keepdim=True) + field /= std_values + + if self.flatten: + field = field.view(self.function_set_size, -1) + + self.grf = field.unsqueeze(-1) + + def get_function(self, idx): + if isinstance(idx, int): idx = [idx] + self.current_idx = idx + return Points(self.grf[self.current_idx], self.function_space.output_space) + + def compute_normalization(self): + if self.grf is None: + self.create_functions() + self.mean_tensor = torch.mean(self.grf, dim=0, keepdim=True) + self.std_tensor = torch.std(self.grf, dim=0, keepdim=True) + + def compute_pca(self, components, normalize_data = True): + if self.grf is None: + self.create_functions() + + data_copy = self.grf + if normalize_data: + data_copy = (self.grf - self.mean) / self.std + + self.pca = torch.pca_lowrank(torch.flatten(data_copy, 1), q=components) \ No newline at end of file diff --git a/src/torchphysics/problem/domains/functionsets/harmonic_functionset.py b/src/torchphysics/problem/domains/functionsets/harmonic_functionset.py index 1c75b8d8..96900a67 100644 --- a/src/torchphysics/problem/domains/functionsets/harmonic_functionset.py +++ b/src/torchphysics/problem/domains/functionsets/harmonic_functionset.py @@ -1,81 +1,180 @@ import torch import math -from ...spaces.points import Points -from .functionset import TestFunctionSet -from ..domain1D import Interval - - -class HarmonicFunctionSet1D(TestFunctionSet): - - def __init__(self, function_space, interval : Interval, frequence, - samples_per_max_frequence : int = 5): - super().__init__(function_space=function_space) - self.interval = interval - self.samples_max = samples_per_max_frequence - - if isinstance(frequence, list): - self.basis_dim = max(frequence) - self.frequence_list = frequence - else: - self.basis_dim = frequence - self.frequence_list = torch.arange(1, frequence+1, 1) - - quad_points = torch.linspace(self.interval.lower_bound(), self.interval.upper_bound(), - self.basis_dim * self.samples_max + 2)[1:-1] - self.quadrature_points_per_dof = quad_points.repeat((self.basis_dim, 1)).unsqueeze(-1) - self.quadrature_weights_per_dof = quad_points[1] - quad_points[0] - - self.compute_basis_at_quadrature_points() - - - def switch_quadrature_mode_on(self, set_on : bool): - self.quadrature_mode_on = set_on - if not set_on: - AssertionError("Arbritrary evaluation not implemented!") - - - def to(self, device): - self.quadrature_points_per_dof = self.quadrature_points_per_dof.to(device) - self.quadrature_weigths_per_dof = self.quadrature_weights_per_dof.to(device) - self.basis_at_quadrature = self.basis_at_quadrature.to(device) - self.grad_at_quadrature = self.grad_at_quadrature.to(device) - - - def compute_basis_at_quadrature_points(self): - self.basis_at_quadrature = torch.zeros_like(self.quadrature_points_per_dof) - self.grad_at_quadrature = torch.zeros_like(self.quadrature_points_per_dof) - - int_size = self.interval.upper_bound() - self.interval.lower_bound() - for i, n in enumerate(self.frequence_list): - self.basis_at_quadrature[i] = \ - torch.sin(n*math.pi/(int_size) * \ - (self.quadrature_points_per_dof[i] - self.interval.lower_bound())) - self.grad_at_quadrature[i] = -n*math.pi/(int_size) * \ - torch.cos(n*math.pi/(int_size) * \ - (self.quadrature_points_per_dof[i] - self.interval.lower_bound())) +from .functionset import FunctionSet + +from ...spaces import Points + +class HarmonicFunctionSet1D(FunctionSet): + """ A function set that creates harmonic functions in 1D. + The functions are of the form + .. math:: \sum_{i=0}^{N} a_i \sin(\frac{2\pi i x}{L}) + b_i \cos(\frac{2\pi i x}{L}) + where N is the maximum frequence, L is the period length and + a_i, b_i are the fourier coefficients, which are created randomly. + + Parameters + ---------- + function_space : tp.spaces.FunctionSpace + The function space of the functions in the set. + function_set_size : int + The number of functions in the set. This sets how many a_i, b_i are created + at once. + period : float + The length of the underyling interval. + max_frequence : int + The maximum frequence of the functions that are created. + random_sample_fn : callable, optional + A function that creates random samples to initialize the fourier coefficients. + Default is torch.randn. + """ + def __init__(self, function_space, function_set_size, + period, max_frequence, + random_sample_fn = torch.randn): + super().__init__(function_space, function_set_size) + self.max_frequence = max_frequence + self.period_len = period + self.random_sample_fn = random_sample_fn + + def create_functions(self, device="cpu"): + self.fourier_coefficients = self.random_sample_fn( + (self.function_set_size, self.max_frequence+1, 2), device=device + ) + + def get_function(self, idx): + if isinstance(idx, int): idx = [idx] + self.current_idx = idx + return self._eval_basis_at_locaction + + def _eval_basis_at_locaction(self, location : Points): + location_copy = self._transform_locations(location) - def __call__(self, x=None): - if self.quadrature_mode_on: - input_variable_name = self.function_space.input_space.variables.pop() - return Points(self.eval_fn_helper.apply(x[input_variable_name], - self.basis_at_quadrature, - self.grad_at_quadrature), - self.function_space.output_space) - else: - raise NotImplementedError + output = torch.zeros((len(self.current_idx), location_copy.shape[1], 1), + device=location.as_tensor.device) + pi_scale = 2 * math.pi / self.period_len + for i in range(self.max_frequence+1): + output[:, :, 0] += \ + self.fourier_coefficients[self.current_idx, i:i+1, 0] * torch.sin(pi_scale * i * location_copy[:, :, 0]) + \ + self.fourier_coefficients[self.current_idx, i:i+1, 1] * torch.cos(pi_scale * i * location_copy[:, :, 0]) - def grad(self, x=None): - if self.quadrature_mode_on or x == None: - return self.grad_at_quadrature + return Points(output, self.function_space.output_space) + +class HarmonicFunctionSet2D(HarmonicFunctionSet1D): + """ A function set that creates harmonic functions in the given dimension. + The functions are build from a fourier basis in the given space, + see also https://en.wikipedia.org/wiki/Multidimensional_transform for the + mathematical background. + + Parameters + ---------- + function_space : tp.spaces.FunctionSpace + The function space of the functions in the set. + function_set_size : int + The number of functions in the set. This sets how many a_i, b_i are created + at once. + period : list or tuple + The length of the underyling domain in each space direction. + max_frequence : list or tuple + The maximum frequence of the functions in each space direction. + random_sample_fn : callable, optional + A function that creates random samples to initialize the fourier coefficients. + Default is torch.randn. + """ + def __init__(self, function_space, function_set_size, + period, max_frequence, + random_sample_fn = torch.randn): + assert isinstance(period, (list, tuple)) + assert isinstance(max_frequence, (list, tuple)) + super().__init__(function_space, function_set_size, period, max_frequence, random_sample_fn) + + + def create_functions(self, device="cpu"): + self.fourier_coefficients = self.random_sample_fn( + (self.function_set_size, self.max_frequence[0]+1, self.max_frequence[1]+1, 4), device=device + ) + + + def _eval_basis_at_locaction(self, location : Points): + location_copy = self._transform_locations(location) + + shape = [len(self.current_idx)] + shape.extend(location_copy.shape[1:-1]) + shape.append(1) + output = torch.zeros(shape, device=location.as_tensor.device) + + pi_scale_x = 2 * math.pi / self.period_len[0] + pi_scale_y = 2 * math.pi / self.period_len[1] + + cast_tensor = [1] * len(location_copy.shape) + cast_tensor[0] = -1 + + for i in range(self.max_frequence[0]+1): + sin_x = torch.sin(pi_scale_x * i * location_copy[..., 0:1]) + cos_x = torch.cos(pi_scale_x * i * location_copy[..., 0:1]) + + for j in range(self.max_frequence[1]+1): + sin_y = torch.sin(pi_scale_y * j * location_copy[..., 1:2]) + cos_y = torch.cos(pi_scale_y * j * location_copy[..., 1:2]) + + output[..., 0:1] += \ + self.fourier_coefficients[self.current_idx, i, j, 0].view(cast_tensor) * sin_x * sin_y + \ + self.fourier_coefficients[self.current_idx, i, j, 1].view(cast_tensor) * cos_x * sin_y + \ + self.fourier_coefficients[self.current_idx, i, j, 2].view(cast_tensor) * sin_x * cos_y + \ + self.fourier_coefficients[self.current_idx, i, j, 3].view(cast_tensor) * cos_x * cos_y + + return Points(output, self.function_space.output_space) + - def get_quad_weights(self, n): - repeats = n // len(self.quadrature_weights_per_dof) - return self.quadrature_weights_per_dof.repeat((repeats, 1, 1)) +class HarmonicFunctionSet3D(HarmonicFunctionSet2D): - def get_quadrature_points(self): - return Points(self.quadrature_points_per_dof, self.function_space.input_space) \ No newline at end of file + def create_functions(self, device="cpu"): + self.fourier_coefficients = self.random_sample_fn( + (self.function_set_size, + self.max_frequence[0]+1, + self.max_frequence[1]+1, + self.max_frequence[2]+1, + 8), device=device + ) + + def _eval_basis_at_locaction(self, location : Points): + location_copy = self._transform_locations(location) + + shape = [len(self.current_idx)] + shape.extend(location_copy.shape[1:-1]) + shape.append(1) + output = torch.zeros(shape, device=location.as_tensor.device) + + pi_scale_x = 2 * math.pi / self.period_len[0] + pi_scale_y = 2 * math.pi / self.period_len[1] + pi_scale_z = 2 * math.pi / self.period_len[1] + + cast_tensor = [1] * len(location_copy.shape) + cast_tensor[0] = -1 + + for i in range(self.max_frequence[0]+1): + sin_x = torch.sin(pi_scale_x * i * location_copy[..., 0:1]) + cos_x = torch.cos(pi_scale_x * i * location_copy[..., 0:1]) + + for j in range(self.max_frequence[1]+1): + sin_y = torch.sin(pi_scale_y * j * location_copy[..., 1:2]) + cos_y = torch.cos(pi_scale_y * j * location_copy[..., 1:2]) + + for k in range(self.max_frequence[2]+1): + sin_z = torch.sin(pi_scale_z * k * location_copy[..., 2:3]) + cos_z = torch.cos(pi_scale_z * k * location_copy[..., 2:3]) + + + output[..., 0:1] += \ + self.fourier_coefficients[self.current_idx, i, j, k, 0].view(cast_tensor) * sin_x * sin_y * sin_z + \ + self.fourier_coefficients[self.current_idx, i, j, k, 1].view(cast_tensor) * sin_x * sin_y * cos_z + \ + self.fourier_coefficients[self.current_idx, i, j, k, 2].view(cast_tensor) * sin_x * cos_y * cos_z + \ + self.fourier_coefficients[self.current_idx, i, j, k, 3].view(cast_tensor) * sin_x * cos_y * sin_z + \ + self.fourier_coefficients[self.current_idx, i, j, k, 4].view(cast_tensor) * cos_x * sin_y * sin_z + \ + self.fourier_coefficients[self.current_idx, i, j, k, 5].view(cast_tensor) * cos_x * sin_y * cos_z + \ + self.fourier_coefficients[self.current_idx, i, j, k, 6].view(cast_tensor) * cos_x * cos_y * cos_z + \ + self.fourier_coefficients[self.current_idx, i, j, k, 7].view(cast_tensor) * cos_x * cos_y * sin_z + + return Points(output, self.function_space.output_space) \ No newline at end of file diff --git a/src/torchphysics/problem/samplers/__init__.py b/src/torchphysics/problem/samplers/__init__.py index e61a93b9..10c078da 100644 --- a/src/torchphysics/problem/samplers/__init__.py +++ b/src/torchphysics/problem/samplers/__init__.py @@ -41,3 +41,9 @@ from .grid_samplers import GridSampler, ExponentialIntervalSampler from .plot_samplers import PlotSampler, AnimationSampler from .data_samplers import DataSampler + +from .function_sampler import ( + FunctionSampler, + FunctionSamplerRandomUniform, + FunctionSamplerOrdered, + FunctionSamplerCoupled) \ No newline at end of file diff --git a/src/torchphysics/problem/samplers/data_samplers.py b/src/torchphysics/problem/samplers/data_samplers.py index 9201dc1a..0ad18fb5 100644 --- a/src/torchphysics/problem/samplers/data_samplers.py +++ b/src/torchphysics/problem/samplers/data_samplers.py @@ -30,6 +30,9 @@ def __init__(self, points): n = len(self.points.as_tensor) super().__init__(n_points=n) + def __len__(self): + return self.points._t.shape[-2] + def sample_points(self, params=Points.empty(), device="cpu"): self.points = self.points.to(device) @@ -42,23 +45,23 @@ def sample_points(self, params=Points.empty(), device="cpu"): # (For example evaluation on quadrature points) # TODO: Make more general. What happends when parameters have higher dimension? # What when multiple dimension in both that do not fit? - start_time = time.time() - if len(self.points.as_tensor.shape) > 2: - repeated_tensor = params.as_tensor - for i in range(1, len(self.points.as_tensor.shape)-1): - repeated_tensor = torch.repeat_interleave(repeated_tensor.unsqueeze(-1), - self.points.as_tensor.shape[i], - dim=i) + # start_time = time.time() + # if len(self.points.as_tensor.shape) > 2: + # repeated_tensor = params.as_tensor + # for i in range(1, len(self.points.as_tensor.shape)-1): + # repeated_tensor = torch.repeat_interleave(repeated_tensor.unsqueeze(-1), + # self.points.as_tensor.shape[i], + # dim=i) - repeated_params = Points(repeated_tensor, params.space) - print("Dimension thing took", time.time() - start_time) + # repeated_params = Points(repeated_tensor, params.space) + # print("Dimension thing took", time.time() - start_time) - # else we have to repeat data (meshgrid of both) and join the tensors together: - start_time = time.time() - repeated_params = self._repeat_params(repeated_params, len(self)) - print("Repeating params took", time.time() - start_time) - start_time = time.time() - repeated_points = self.points.repeat(len(params)) - print("Repeating points took", time.time() - start_time) + # # else we have to repeat data (meshgrid of both) and join the tensors together: + # start_time = time.time() + # repeated_params = self._repeat_params(repeated_params, len(self)) + # print("Repeating params took", time.time() - start_time) + # start_time = time.time() + # repeated_points = self.points.repeat(len(params)) + # print("Repeating points took", time.time() - start_time) - return repeated_points.join(repeated_params) \ No newline at end of file + # return repeated_points.join(repeated_params) \ No newline at end of file diff --git a/src/torchphysics/problem/samplers/function_sampler.py b/src/torchphysics/problem/samplers/function_sampler.py new file mode 100644 index 00000000..aeea6836 --- /dev/null +++ b/src/torchphysics/problem/samplers/function_sampler.py @@ -0,0 +1,102 @@ +import abc +import torch + +from ..domains.functionsets import FunctionSet + + +class FunctionSampler: + """Handles the sampling of functions from a function set. Acts similar to a dataloader. + + Parameters + ---------- + n_functions : int + The number of functions that should be sampled when calling sample_functions. + function_set : tp.domains.FunctionSet + The function set from which functions should be sampled. Note that the size of the + functions set needs to be larger or eqaul to n_functions. + function_creation_interval : int, optional + functions set needs to be larger or equal to n_functions. + function_creation_interval : int + The interval at which new functions should be created. If set to 0, new functions are + created every time sample_functions is called. + The creation of new functions is handled by the function set. + The default value is 0. + """ + def __init__(self, n_functions, function_set : FunctionSet, function_creation_interval : int = 0): + self.n_functions = n_functions + self.function_set = function_set + self.function_creation_interval = function_creation_interval + assert self.n_functions <= self.function_set.function_set_size, \ + "The number of functions to be sampled must be smaller than the function set size." + + self.iteration_counter = self.function_creation_interval + self.current_indices = torch.zeros(n_functions, dtype=torch.int64) + + + def _check_recreate_functions(self, device="cpu"): + if self.iteration_counter >= self.function_creation_interval: + self.function_set.create_functions(device=device) + self.iteration_counter = -1 + self.iteration_counter += 1 + + @abc.abstractmethod + def sample_functions(self, device="cpu"): + """ Sample functions from the function set. + + Parameters + ---------- + device : str, optional + The device on which the functions should be stored. Default is cpu. + + Returns + ------- + callable or torch.tensor + Returns the sampled functions. If the function set is discrete, the functions + can not be further evaluated and are therefore returned as a tensor. Otherwise + a callable is returned that can be evaluated at any point. + """ + raise NotImplementedError + + +class FunctionSamplerRandomUniform(FunctionSampler): + """ Randomly samples functions from the function set. + """ + def sample_functions(self, device="cpu"): + self._check_recreate_functions(device=device) + self.current_indices = torch.randperm(self.function_set.function_set_size)[:self.n_functions] + return self.function_set.get_function(self.current_indices) + + +class FunctionSamplerOrdered(FunctionSampler): + """ Samples functions in a ordered manner from the function set. When called + will return the first n_functions functions from the function set and then increment + the indices by n_functions. If the end of the function set is reached, the indices + are reset to the beginning. + """ + def __init__(self, n_functions, function_set : FunctionSet, function_creation_interval : int = 0): + super().__init__(n_functions, function_set, function_creation_interval) + self.current_indices = torch.arange(self.n_functions, dtype=torch.int64) + + def sample_functions(self, device="cpu"): + self._check_recreate_functions(device=device) + current_out = self.function_set.get_function(self.current_indices) + self.current_indices = (self.current_indices + self.n_functions) % self.function_set.function_set_size + return current_out + + +class FunctionSamplerCoupled(FunctionSampler): + """ A sampler that is coupled to another sampler, such that the same indices + of functions are sampled from both samplers. + Can be usefull is two different data function sets are used where the data of + both sets is coupled and should therefore be samples accordingly. + """ + def __init__(self, function_set : FunctionSet, coupled_sampler : FunctionSampler): + super().__init__(coupled_sampler.n_functions, function_set, + coupled_sampler.function_creation_interval) + self.coupled_sampler = coupled_sampler + + def sample_functions(self, device="cpu"): + self._check_recreate_functions(device=device) + + self.current_indices = self.coupled_sampler.current_indices + return self.function_set.get_function(self.current_indices) \ No newline at end of file diff --git a/src/torchphysics/problem/samplers/random_samplers.py b/src/torchphysics/problem/samplers/random_samplers.py index 82a14997..ef63f7e7 100644 --- a/src/torchphysics/problem/samplers/random_samplers.py +++ b/src/torchphysics/problem/samplers/random_samplers.py @@ -64,19 +64,24 @@ def _sample_n_points_with_filter(self, params, device): for i in range(num_of_params): new_sample_points = None num_of_new_points = 0 + total_sampled_points = 0 iterations = 0 + n_sample_points = self.n_points # we have to make sure to sample for each param exactly n points while num_of_new_points < self.n_points: # sample points - new_points = self._sample_for_ith_param( - sample_function, params, i, device - ) + new_points = self._sample_for_ith_param(sample_function, params, + i, device, n_points=n_sample_points) + total_sampled_points += n_sample_points # apply filter and save valid points new_points = self._apply_filter(new_points) - num_of_new_points += len(new_points) - new_sample_points = self._set_sampled_points( - new_sample_points, new_points - ) + num_of_new_points = max(1 , num_of_new_points + len(new_points)) + n_sample_points = int(1.1*(self.n_points - num_of_new_points)\ + *total_sampled_points/num_of_new_points)+10 + if n_sample_points > 1.e9: + raise RuntimeError("To many points need to be sampled to fulfill filter condition!") + new_sample_points = self._set_sampled_points(new_sample_points, + new_points) iterations += 1 self._check_iteration_number(iterations, num_of_new_points) # if to many points were sampled, delete them. diff --git a/src/torchphysics/problem/samplers/sampler_base.py b/src/torchphysics/problem/samplers/sampler_base.py index f63883c0..0d50ecb2 100644 --- a/src/torchphysics/problem/samplers/sampler_base.py +++ b/src/torchphysics/problem/samplers/sampler_base.py @@ -205,9 +205,11 @@ def _sample_params_dependent(self, sample_function, params, device): sample_points = self._set_sampled_points(sample_points, new_points) return sample_points - def _sample_for_ith_param(self, sample_function, params, i, device): - ith_params = params[i,] if len(params) > 0 else Points.empty() - new_points = sample_function(self.n_points, self.density, ith_params, device) + def _sample_for_ith_param(self, sample_function, params, i, device, n_points=None): + if n_points is None: + n_points = self.n_points + ith_params = params[i, ] if len(params) > 0 else Points.empty() + new_points = sample_function(n_points, self.density, ith_params, device) num_of_points = len(new_points) repeated_params = self._repeat_params(ith_params, num_of_points) return new_points.join(repeated_params) @@ -236,7 +238,7 @@ def _check_iteration_number(self, iterations, num_of_new_points): {num_of_new_points} from {self.n_points} points. This may take some time.""" ) - elif iterations >= 20 and num_of_new_points == 0: + elif iterations >= 20 and num_of_new_points <= 1: raise RuntimeError( """Run 20 iterations and could not find a single valid point for the filter condition.""" @@ -345,6 +347,7 @@ class StaticSampler(PointSampler): """ def __init__(self, sampler, resample_interval=math.inf): + super().__init__(sampler.n_points, sampler.density, sampler.filter_fn) self.length = None self.sampler = sampler self.created_points = None diff --git a/src/torchphysics/problem/spaces/__init__.py b/src/torchphysics/problem/spaces/__init__.py index ff9719ec..da2ba618 100644 --- a/src/torchphysics/problem/spaces/__init__.py +++ b/src/torchphysics/problem/spaces/__init__.py @@ -11,6 +11,6 @@ The second axis collects the space dimensionalities. """ -from .space import Space, R1, R2, R3, Rn +from .space import Space, R1, R2, R3, Rn, Z1, Z2, Z3, Zn, N1, N2, N3, Nn from .points import Points from .functionspace import FunctionSpace diff --git a/src/torchphysics/problem/spaces/functionspace.py b/src/torchphysics/problem/spaces/functionspace.py index c9812bce..dbb47016 100644 --- a/src/torchphysics/problem/spaces/functionspace.py +++ b/src/torchphysics/problem/spaces/functionspace.py @@ -5,13 +5,31 @@ class FunctionSpace: Parameters ---------- - input_domain : torchphysics.Domain - The input domain of the functions in this function space. + input_space : torchphysics.Space + The space of the input domain of the functions in this function space. output_space : torchphysics.Space The space of the image of the functions in this function space. """ - def __init__(self, input_domain, output_space): - self.input_domain = input_domain + def __init__(self, input_space, output_space): + self.input_space = input_space self.output_space = output_space - self.input_space = self.input_domain.space + + + def __mul__(self, other): + """Creates the product space of the two input spaces. Allows the + construction of higher dimensional spaces with 'mixed' variable names. + E.g R1('x')*R1('y') is a two dimensional space where one axis is 'x' + and the other stands for 'y'. + """ + assert isinstance(other, FunctionSpace), "Can only multiply FunctionSpaces" + assert not (self.output_space == other.output_space), "Output spaces must be different" + if self.input_space == other.input_space: + return FunctionSpace(self.input_space, self.output_space * other.output_space) + elif self.input_space in other.input_space: + return FunctionSpace(other.input_space, self.output_space * other.output_space) + elif other.input_space in self.input_space: + return FunctionSpace(self.input_space, self.output_space * other.output_space) + else: + return FunctionSpace(self.input_space*other.input_space, + self.output_space * other.output_space) diff --git a/src/torchphysics/problem/spaces/points.py b/src/torchphysics/problem/spaces/points.py index 28e262be..d8d445f4 100644 --- a/src/torchphysics/problem/spaces/points.py +++ b/src/torchphysics/problem/spaces/points.py @@ -29,8 +29,8 @@ class Points: """ def __init__(self, data, space, **kwargs): - self._t = torch.as_tensor(data, **kwargs) self.space = space + self._t = space.cast_tensor_into_space(torch.as_tensor(data, **kwargs)) assert len(self._t.shape) >= 2 assert ( self._t.shape[-1] == self.space.dim @@ -218,6 +218,11 @@ def __getitem__(self, val): Supports usual slice operations like points[1:3,('x','t')]. Returns a new, sliced, points object. """ + if isinstance(val, Space): + if val.variables == self.space.variables: + return self + else: + return self[:, self.space.variables] val, space = self._compute_slice(val) out = self._t[val] if len(out.shape) == 1: diff --git a/src/torchphysics/problem/spaces/space.py b/src/torchphysics/problem/spaces/space.py index ad933897..1e02d3fa 100644 --- a/src/torchphysics/problem/spaces/space.py +++ b/src/torchphysics/problem/spaces/space.py @@ -1,3 +1,4 @@ +import torch from collections import Counter, OrderedDict @@ -17,6 +18,18 @@ def __init__(self, variables_dims): # set counter of variable names and their dimensionalities super().__init__(variables_dims) + def cast_tensor_into_space(self, data_tensor): + """Applies transformations to the tensor such that the constrains + of the space are fulfilled. E.g. rounds the input to integer values. + + Parameters + ---------- + data_tensor : torch.tensor + The tensor which data should be casted, such that it fulfills the + constrains of this space. + """ + return data_tensor + def __mul__(self, other): """Creates the product space of the two input spaces. Allows the construction of higher dimensional spaces with 'mixed' variable names. @@ -173,33 +186,67 @@ def __init__(self, variable_name, n: int): super().__init__({variable_name: n}) -# class M(Space): -# """The space for n x m matricies. (currently only real numbers) - -# Parameters -# ---------- -# variable_name: str -# The name of the variable that belongs to this space. -# n : int -# The number of rows of the matricies. -# m : int -# The number of columns. -# """ -# def __init__(self, variable_name, n : int, m : int): -# self.rows = n -# self.columns = m -# super().__init__({variable_name: n*m}) - -# def __mul__(self, other): -# raise NotImplementedError("Matrix-spaces can not be multiplied!") - -# def check_values_in_space(self, values): -# v_shape = values.shape -# if len(v_shape) >= 3 and v_shape[-2] == self.rows and v_shape[-1] == self.columns: -# # values aready in correct shape -# return values -# if values.shape[-1] == self.dim: -# # maybe values are given as a vector with correct dimension -# # -> reshape to matrix -# return values.reshape(-1, self.rows, self.columns) -# raise AssertionError("Values do not belong to a matrix-space") +class IntegerSpace(Space): + + def __init__(self, variable_name, dim): + super().__init__({variable_name: dim}) + + def cast_tensor_into_space(self, data_tensor): + return torch.round(data_tensor) # to keep same type + + +class Z1(IntegerSpace): + """The space for one dimensional integer numbers. + """ + def __init__(self, variable_name): + super().__init__(variable_name, 1) + +class Z2(IntegerSpace): + """The space for two dimensional integer numbers. + """ + def __init__(self, variable_name): + super().__init__(variable_name, 2) + +class Z3(IntegerSpace): + """The space for three dimensional integer numbers. + """ + def __init__(self, variable_name): + super().__init__(variable_name, 3) + +class Zn(IntegerSpace): + """The space for n dimensional integer numbers. + """ + def __init__(self, variable_name, n): + super().__init__(variable_name, n) + + +class NaturalNumberSpace(Space): + def __init__(self, variable_name, dim): + super().__init__({variable_name: dim}) + + def cast_tensor_into_space(self, data_tensor): + return torch.round(data_tensor).abs() # to keep same type + +class N1(NaturalNumberSpace): + """The space for one dimensional natural numbers including 0. + """ + def __init__(self, variable_name): + super().__init__(variable_name, 1) + +class N2(NaturalNumberSpace): + """The space for two dimensional natural numbers including 0. + """ + def __init__(self, variable_name): + super().__init__(variable_name, 2) + +class N3(NaturalNumberSpace): + """The space for three dimensional natural numbers including 0. + """ + def __init__(self, variable_name): + super().__init__(variable_name, 3) + +class Nn(NaturalNumberSpace): + """The space for n dimensional natural numbers including 0. + """ + def __init__(self, variable_name, n): + super().__init__(variable_name, n) \ No newline at end of file diff --git a/src/torchphysics/utils/__init__.py b/src/torchphysics/utils/__init__.py index cca0d359..1ae687db 100644 --- a/src/torchphysics/utils/__init__.py +++ b/src/torchphysics/utils/__init__.py @@ -8,7 +8,7 @@ torchphysics.utils.plotting """ -from .differentialoperators import ( +from .differentialoperators.differentialoperators import ( laplacian, grad, div, @@ -21,6 +21,11 @@ matrix_div, ) +from .differentialoperators.differenceoperators import ( + discrete_grad_on_grid, + discrete_laplacian_on_grid +) + from .data import PointsDataset, PointsDataLoader, DeepONetDataLoader from .user_fun import UserFunction diff --git a/src/torchphysics/utils/differentialoperators/differenceoperators.py b/src/torchphysics/utils/differentialoperators/differenceoperators.py new file mode 100644 index 00000000..5e4e1269 --- /dev/null +++ b/src/torchphysics/utils/differentialoperators/differenceoperators.py @@ -0,0 +1,150 @@ +"""File contains difference operators to approximate derivatives of +discrete functions. Intended for the derivatives of operator approaches like FNO. +""" +import torch + + +def discrete_grad_on_grid(model_out, grid_size): + """ Approximates the gradient of a discrete function using finite differences. + + Parameters + ---------- + model_out : torch.Tensor + The discrete function to approximate the gradient for. + grid_size : float + The step size used for the finite difference approximation and underlying grid. + + Notes + ----- + This methode assumes that the input function which the gradient should be + computed of is defined on a regular equidistant grid. + The shape of function is assumed to be of the form + (batch_size, N_1, N_2, ..., N_d, dim), + where dim is the output dimension of the functions and N_i is the + resolution in the different space directions. + The gradient will computed in all d directions. + A central difference scheme is used for the approximation and + at the boundary a one-sided difference scheme is used (also of order 2). + """ + number_of_dims = len(model_out.shape) - 2 + gradient = torch.zeros(*model_out.shape[:-1], number_of_dims * model_out.shape[-1], + device=model_out.device) + + write_to_slice = [slice(None)] * len(model_out.shape) + read_from_slice_left = [slice(None)] * len(model_out.shape) + read_from_slice_right = [slice(None)] * len(model_out.shape) + read_from_slice_one_sided = [slice(None)] * len(model_out.shape) + + for i in range(number_of_dims): + # Update the last dimension to wrtie the correct gradient components + write_to_slice[-1] = slice(i * model_out.shape[-1], (i + 1) * model_out.shape[-1]) + + # pick correct dimenison for the current direction + write_to_slice[i+1] = slice(1, -1) + read_from_slice_left[i+1] = slice(2, None) + read_from_slice_right[i+1] = slice(0, -2) + + # central gradient scheme + gradient[write_to_slice] = \ + (model_out[read_from_slice_left] - model_out[read_from_slice_right]) / (2 * grid_size) + + # At boundary one-sided difference scheme + # "Left" boundary + write_to_slice[i+1] = slice(0, 1) + read_from_slice_left[i+1] = slice(0, 1) + read_from_slice_right[i+1] = slice(1, 2) + read_from_slice_one_sided[i+1] = slice(2, 3) + gradient[write_to_slice] = \ + (- 1.5 * model_out[read_from_slice_left] \ + + 2 * model_out[read_from_slice_right] \ + - 0.5 * model_out[read_from_slice_one_sided]) / grid_size + # "Right" boundary + write_to_slice[i+1] = slice(-1, None) + read_from_slice_left[i+1] = slice(-1, None) + read_from_slice_right[i+1] = slice(-2, -1) + read_from_slice_one_sided[i+1] = slice(-3, -2) + gradient[write_to_slice] = \ + (1.5 * model_out[read_from_slice_left] \ + - 2 * model_out[read_from_slice_right] \ + + 0.5 * model_out[read_from_slice_one_sided]) / grid_size + + # reset + write_to_slice[i+1] = slice(None) + read_from_slice_left[i+1] = slice(None) + read_from_slice_right[i+1] = slice(None) + read_from_slice_one_sided[i+1] = slice(None) + + return gradient + + +def discrete_laplacian_on_grid(model_out, grid_size): + """ Approximates the laplacian of a discrete function using finite differences. + + Parameters + ---------- + model_out : torch.Tensor + The discrete function to approximate the laplacian for. + grid_size : float + The step size used for the finite difference approximation and underlying grid. + + Notes + ----- + This methode assumes the same properties as `discrete_grad_on_grid`. + """ + number_of_dims = len(model_out.shape) - 2 + laplace = torch.zeros(*model_out.shape, device=model_out.device) + + write_to_slice = [slice(None)] * len(model_out.shape) + read_from_slice_left = [slice(None)] * len(model_out.shape) + read_from_slice_right = [slice(None)] * len(model_out.shape) + read_from_slice_center = [slice(None)] * len(model_out.shape) + read_from_slice_one_sided = [slice(None)] * len(model_out.shape) + + for i in range(number_of_dims): + # pick correct dimenison for the current direction + write_to_slice[i+1] = slice(1, -1) + read_from_slice_center[i+1] = slice(1, -1) + read_from_slice_left[i+1] = slice(2, None) + read_from_slice_right[i+1] = slice(0, -2) + + # central gradient scheme + laplace[write_to_slice] += \ + (model_out[read_from_slice_left] + - 2 * model_out[read_from_slice_center] + + model_out[read_from_slice_right]) / (grid_size**2) + + # At boundary one-sided difference scheme + # "Left" boundary + write_to_slice[i+1] = slice(0, 1) + read_from_slice_left[i+1] = slice(0, 1) + read_from_slice_center[i+1] = slice(1, 2) + read_from_slice_right[i+1] = slice(2, 3) + read_from_slice_one_sided[i+1] = slice(3, 4) + + laplace[write_to_slice] += \ + (2.0 * model_out[read_from_slice_left] \ + - 5.0 * model_out[read_from_slice_center] \ + + 4.0 * model_out[read_from_slice_right] \ + - 1.0 * model_out[read_from_slice_one_sided]) / (grid_size**2) + + # "Right" boundary + write_to_slice[i+1] = slice(-1, None) + read_from_slice_left[i+1] = slice(-3, -2) + read_from_slice_center[i+1] = slice(-2, -1) + read_from_slice_right[i+1] = slice(-1, None) + read_from_slice_one_sided[i+1] = slice(-4, -3) + + laplace[write_to_slice] += \ + (2.0 * model_out[read_from_slice_right] \ + - 5.0 * model_out[read_from_slice_center] \ + + 4.0 * model_out[read_from_slice_left] \ + - 1.0 * model_out[read_from_slice_one_sided]) / (grid_size**2) + + # reset + write_to_slice[i+1] = slice(None) + read_from_slice_center[i+1] = slice(None) + read_from_slice_left[i+1] = slice(None) + read_from_slice_right[i+1] = slice(None) + read_from_slice_one_sided[i+1] = slice(None) + + return laplace \ No newline at end of file diff --git a/src/torchphysics/utils/differentialoperators.py b/src/torchphysics/utils/differentialoperators/differentialoperators.py similarity index 100% rename from src/torchphysics/utils/differentialoperators.py rename to src/torchphysics/utils/differentialoperators/differentialoperators.py diff --git a/src/torchphysics/utils/plotting/animation.py b/src/torchphysics/utils/plotting/animation.py index f6fc9a03..b31ecd27 100644 --- a/src/torchphysics/utils/plotting/animation.py +++ b/src/torchphysics/utils/plotting/animation.py @@ -384,8 +384,11 @@ def animate(frame_number, outputs, con, triangulation): current_ani = animation_points[frame_number,] # remove old contour if isinstance(con[0], plt_tri.TriContourSet): - for tp in con[0].collections: - tp.remove() + if hasattr(con[0], "collections"): + for tp in con[0].collections: + tp.remove() + else: + con[0].remove() # have to create a new triangulation, if the domain changes if not ani_sampler.plot_domain_constant: triangulation = _triangulate_for_animation( diff --git a/tests/test_spaces.py b/tests/test_spaces.py index b840a12f..6c8dd847 100644 --- a/tests/test_spaces.py +++ b/tests/test_spaces.py @@ -1,8 +1,10 @@ +import pytest +import torch from collections import Counter, OrderedDict -from torchphysics.problem.spaces import Space, R1, R2, R3, FunctionSpace -from torchphysics.problem.domains import Interval - +from torchphysics.problem.spaces import ( + Space, R1, R2, R3, Rn, Z1, Z2, Z3, Zn, N1, N2, N3, Nn, FunctionSpace + ) def test_create_space(): s = Space({'x': 1}) @@ -117,9 +119,124 @@ def test_create_R3(): assert isinstance(r, OrderedDict) assert r.dim == 3 +def test_create_Rn(): + r = Rn('x', 10) + assert isinstance(r, Counter) + assert isinstance(r, OrderedDict) + assert r.dim == 10 + + +def test_create_Z1(): + r = Z1('x') + assert isinstance(r, Counter) + assert isinstance(r, OrderedDict) + assert r.dim == 1 + + +def test_create_Z2(): + r = Z2('x') + assert isinstance(r, Counter) + assert isinstance(r, OrderedDict) + assert r.dim == 2 + + +def test_create_Z3(): + r = Z3('x') + assert isinstance(r, Counter) + assert isinstance(r, OrderedDict) + assert r.dim == 3 + +def test_create_Zn(): + r = Zn('x', 5) + assert isinstance(r, Counter) + assert isinstance(r, OrderedDict) + assert r.dim == 5 + + +def test_cast_tensor_into_integers(): + r = Z2('x') + test_tensor = torch.tensor([[1.0, 0.2], [-2.3, 1.7], [3.0, 5]]) + casted_tensor = r.cast_tensor_into_space(test_tensor) + expected_tensor = torch.tensor([[1.0, 0.0], [-2.0, 2.0], [3.0, 5]]) + assert torch.all(casted_tensor == expected_tensor) + + +def test_create_N1(): + r = N1('x') + assert isinstance(r, Counter) + assert isinstance(r, OrderedDict) + assert r.dim == 1 + + +def test_create_N2(): + r = N2('x') + assert isinstance(r, Counter) + assert isinstance(r, OrderedDict) + assert r.dim == 2 + + +def test_create_N3(): + r = N3('x') + assert isinstance(r, Counter) + assert isinstance(r, OrderedDict) + assert r.dim == 3 + +def test_create_Nn(): + r = Nn('x', 134) + assert isinstance(r, Counter) + assert isinstance(r, OrderedDict) + assert r.dim == 134 + +def test_cast_tensor_into_naturals(): + r = N2('x') + test_tensor = torch.tensor([[1.0, 0.2], [-2.3, 1.7], [3.0, 5]]) + casted_tensor = r.cast_tensor_into_space(test_tensor) + expected_tensor = torch.tensor([[1.0, 0.0], [2.0, 2.0], [3.0, 5]]) + assert torch.all(casted_tensor == expected_tensor) + def test_functionspace(): X = R1('x') Y = R2('y') - I = Interval(X, 0, 1) - Z = FunctionSpace(I, Y) - assert Z.input_space == X \ No newline at end of file + Z = FunctionSpace(X, Y) + assert Z.input_space == X + assert Z.output_space == Y + + +def test_functionspace_product(): + X = R1('x') + Y = R2('y') + U = R1("u") + Z1 = FunctionSpace(X, Y) + Z2 = FunctionSpace(X, U) + Z = Z1 * Z2 + assert Z.input_space == X + assert Z.output_space == Y*U + + +def test_functionspace_product_different_input(): + X = R1('x') + T = R2("t") + Y = R2('y') + U = R1("u") + Z1 = FunctionSpace(X, Y) + Z2 = FunctionSpace(T, U) + Z = Z1 * Z2 + assert Z.input_space == X*T + assert Z.output_space == Y*U + + +def test_tensor_in_space_check(): + X = R1("x") + test_tensor = torch.tensor([[1], [2], [3]]) + X.check_values_in_space(test_tensor) + +def test_tensor_in_space_check_2D(): + X = R2("x") + test_tensor = torch.tensor([[1, 2], [2, 1], [3, 5]]) + X.check_values_in_space(test_tensor) + +def test_tensor_not_in_space_check(): + X = R1("x") + test_tensor = torch.tensor([[1, 2], [2, 1], [3, 5]]) + with pytest.raises(AssertionError): + X.check_values_in_space(test_tensor) \ No newline at end of file diff --git a/tests/tests_domain/test_box_3d.py b/tests/tests_domain/test_box_3d.py new file mode 100644 index 00000000..26790685 --- /dev/null +++ b/tests/tests_domain/test_box_3d.py @@ -0,0 +1,333 @@ +import pytest +import torch + +from torchphysics.problem.domains.domain3D.box import (Box, BoxBoundary) +from torchphysics.problem.spaces.space import R3, R1 +from torchphysics.problem.spaces.points import Points + + +def origin(t): + return torch.column_stack((t, t, torch.zeros_like(t))) + +def width(t): + return t + 1.0 + +def height(t): + return t + 2.0 + + +def test_create_Box(): + B = Box(R3('x'), [0.0, 0, 0], 1.0, 1.0, 1.0) + assert all(torch.isclose(torch.tensor(B.origin.fun), torch.tensor([0.0, 0, 0]))) + assert all(torch.isclose(torch.tensor(B.width.fun), torch.tensor([1.0]))) + assert all(torch.isclose(torch.tensor(B.height.fun), torch.tensor([1.0]))) + assert all(torch.isclose(torch.tensor(B.depth.fun), torch.tensor([1.0]))) + assert 'x' in B.space + assert 3 == B.dim + + +def test_create_Box_with_variable_corners(): + B = Box(R3('x'), origin, width, height, width) + assert B.origin.fun == origin + assert B.width.fun == width + assert B.height.fun == height + assert B.depth.fun == width + + +def test_create_Box_mixed_variable_corners(): + B = Box(R3('x'), origin, width, 1.0, 2.0) + assert B.origin.fun == origin + assert B.width.fun == width + assert all(torch.isclose(torch.tensor(B.height.fun), torch.tensor([1.0]))) + assert all(torch.isclose(torch.tensor(B.depth.fun), torch.tensor([2.0]))) + +def test_call_Box(): + B = Box(R3('x'), origin, width, 1.0, 2.0) + B = B(t=torch.tensor(2)) + assert all(torch.isclose(torch.tensor(B.width.fun), torch.tensor([3.0]))) + assert all(torch.isclose(torch.tensor(B.height.fun), torch.tensor([1.0]))) + assert all(torch.isclose(torch.tensor(B.depth.fun), torch.tensor([2.0]))) + + +def test_Box_volume(): + B = Box(R3('x'), [0, 0, 0], 1, 2.0, 5.5) + assert B.volume() == 11.0 + + +def test_Box_volume_with_variable_corners(): + P = Box(R3('x'), [0.0, 0.0, 0.0], width, height, width) + time = Points(torch.tensor([0, 1, 2.0]).reshape(-1, 1), R1('t')) + volume = P.volume(time) + assert all(torch.isclose(volume, torch.tensor([[2.0], [12.0], [36.0]]))) + + +def test_bounding_box_Box(): + P = Box(R3('x'), [0, 0.0, -2.0], 2, 1, 3) + bounds = P.bounding_box() + assert bounds[0] == 0 + assert bounds[1] == 2 + assert bounds[2] == 0 + assert bounds[3] == 1 + assert bounds[4] == -2.0 + assert bounds[5] == 1 + +def test_bounding_box_Box_variable_corners(): + P = Box(R3('x'), origin, width, height, 2.0) + time = Points(torch.tensor([1.0, 2, 3, 4]).reshape(-1, 1), R1('t')) + bounds = P.bounding_box(time) + assert bounds[0] == 1.0 + assert bounds[1] == 9.0 + assert bounds[2] == 1.0 + assert bounds[3] == 10.0 + assert bounds[4] == 0.0 + assert bounds[5] == 2.0 + + +def test_Box_contains(): + P = Box(R3('x'), [0, 0.0, 0.0], 2, 1, 3) + points = torch.tensor([[0.1, 0.1, 1.0], [1.98, 0.1, 1.5], + [0.5, 0.5, -0.1], [-1, -1, -1], [1.9, 0.8, 3.2]]) + points = Points(points, R3('x')) + inside = P._contains(points) + assert all(inside[:2]) + assert not any(inside[2:]) + + +def test_Box_contains_if_origin_changes(): + P = Box(R3('x'), origin, 1, 1, 1) + points = torch.tensor([[0.0, 0.0, 0.1], [1.1, 1.5, 0.5], [1.6, 1.6, 0.1], + [0.0, -0.8, 0.5], [0.0, 0.0, 0.5], [3.0, 3.0, 0.3]]) + time = Points(torch.tensor([0, 1, 1.5, 0, 1, 1.5]).reshape(-1, 1), R1('t')) + points = Points(points, R3('x')) + inside = P._contains(points, time) + assert all(inside[:3]) + assert not any(inside[3:]) + + +def test_Box_random_sampling_with_n(): + P = Box(R3('x'), [0, 0, 0], 2, 3, 1) + points = P.sample_random_uniform(n=40) + assert points.as_tensor.shape == (40, 3) + assert all(points.as_tensor[:, :1] <= 2.0) + assert all(points.as_tensor[:, 1:2] <= 3.0) + assert all(points.as_tensor[:, 2:3] <= 1.0) + assert all(points.as_tensor[:, :1] >= 0.0) + assert all(points.as_tensor[:, 1:2] >= 0.0) + assert all(points.as_tensor[:, 2:3] >= 0.0) + + +def test_Box_random_sampling_with_d(): + P = Box(R3('x'), [0, 0, 0], 2, 3, 1) + points = P.sample_random_uniform(d=11) + assert points.as_tensor.shape == (66, 3) + assert all(points.as_tensor[:, :1] <= 2.0) + assert all(points.as_tensor[:, 1:2] <= 3.0) + assert all(points.as_tensor[:, 2:3] <= 1.0) + assert all(points.as_tensor[:, :1] >= 0.0) + assert all(points.as_tensor[:, 1:2] >= 0.0) + assert all(points.as_tensor[:, 2:3] >= 0.0) + + +def test_Box_random_sampling_with_n_and_variable_origin(): + P = Box(R3('x'), origin, 2, 2, 2) + time = Points(torch.tensor([0, 1]).reshape(-1, 1), R1('t')) + points = P.sample_random_uniform(n=100, params=time) + assert points.as_tensor.shape == (200, 3) + assert all(P._contains(points, Points(torch.repeat_interleave(time, 100, dim=0), R1('t')))) + + +def test_Box_random_sampling_with_n_and_all_corners_variable(): + P = Box(R3('x'), origin, width, height, 3.0) + time = Points(torch.tensor([0, 1]).reshape(-1, 1), R1('t')) + points = P.sample_random_uniform(n=100, params=time) + assert points.as_tensor.shape == (200, 3) + assert all(P._contains(points, Points(torch.repeat_interleave(time, 100, dim=0), R1('t')))) + + +def test_Box_grid_sampling_with_n(): + P = Box(R3('x'), [0, 0, 0], 2, 3, 1) + points = P.sample_grid(n=40) + assert points.as_tensor.shape == (40, 3) + assert all(points.as_tensor[:, :1] <= 2.0) + assert all(points.as_tensor[:, 1:2] <= 3.0) + assert all(points.as_tensor[:, 2:3] <= 1.0) + assert all(points.as_tensor[:, :1] >= 0.0) + assert all(points.as_tensor[:, 1:2] >= 0.0) + assert all(points.as_tensor[:, 2:3] >= 0.0) + +def test_Box_grid_sampling_with_n_perfect(): + P = Box(R3('x'), [0, 0, 0], 1, 1, 1) + points = P.sample_grid(n=1000) + assert points.as_tensor.shape == (1000, 3) + assert all(points.as_tensor[:, :1] <= 1.0) + assert all(points.as_tensor[:, 1:2] <= 1.0) + assert all(points.as_tensor[:, 2:3] <= 1.0) + assert all(points.as_tensor[:, :1] >= 0.0) + assert all(points.as_tensor[:, 1:2] >= 0.0) + assert all(points.as_tensor[:, 2:3] >= 0.0) + + +def test_Box_grid_sampling_with_d(): + P = Box(R3('x'), [0, 0, 0], 2, 3, 1) + points = P.sample_grid(d=11) + assert points.as_tensor.shape == (48, 3) + assert all(points.as_tensor[:, :1] <= 2.0) + assert all(points.as_tensor[:, 1:2] <= 3.0) + assert all(points.as_tensor[:, 2:3] <= 1.0) + assert all(points.as_tensor[:, :1] >= 0.0) + assert all(points.as_tensor[:, 1:2] >= 0.0) + assert all(points.as_tensor[:, 2:3] >= 0.0) + + +def test_Box_grid_sampling_with_n_and_variable_origin(): + P = Box(R3('x'), origin, 2, 2, 2) + time = Points(torch.tensor([0.0]).reshape(-1, 1), R1('t')) + points = P.sample_grid(n=100, params=time) + assert points.as_tensor.shape == (100, 3) + assert all(P._contains(points, Points(torch.repeat_interleave(time, 100, dim=0), R1('t')))) + + +def test_Box_grid_sampling_with_n_and_all_corners_variable(): + P = Box(R3('x'), origin, width, height, 3.0) + time = Points(torch.tensor([0.0]).reshape(-1, 1), R1('t')) + points = P.sample_grid(n=100, params=time) + assert points.as_tensor.shape == (100, 3) + assert all(P._contains(points, Points(torch.repeat_interleave(time, 100, dim=0), R1('t')))) + + +def test_get_Box_boundary(): + P = Box(R3('x'), [0, 0, 0], 1, 1, 1) + boundary = P.boundary + assert boundary.domain == P + assert isinstance(boundary, BoxBoundary) + + +def test_call_Box_boundary(): + P = Box(R3('x'), origin, 1, 2, 1).boundary + P = P(t=torch.tensor(2)) + assert all(torch.isclose(P.domain.origin.fun, torch.tensor([2, 2, 0]))) + assert all(torch.isclose(torch.tensor(P.domain.width.fun), torch.tensor([1]))) + assert all(torch.isclose(torch.tensor(P.domain.height.fun), torch.tensor([2]))) + + +def test_Box_boundary_contains(): + P = Box(R3('x'), [0, 0, 0], 1, 1, 1).boundary + points = torch.tensor([[0, 0, 0], [0.5, 0, 0], [1, 0, 0], [0.5, 0.3, 0.0], [0.3, 1, 0.5], + [0.1, 0.1, 0.1], [-0.5, 0, 0], [0.5, 0.5, 0.5], [1.5, 1.5, 0.0], + [0, 0, -1]]) + points = Points(points, R3('x')) + inside = P._contains(points) + assert all(inside[:5]) + assert not any(inside[5:]) + + +def test_Box_boundary_contains_if_corners_change(): + P = Box(R3('x'), origin, 1, 1, 1).boundary + points = torch.tensor([[0, 0, 0], [1, 0, 0], [1.5, 1.5, 0.0], [1.7, 1.1, 1.0], + [1.5, 1.5, 0.0], [-0.1, -5, 20.0], [0, 0, 0.0], [2.1, 1.0, 0.0]]) + time = torch.tensor([0, 0, 1, 1, 0, 0, 1, 1]).reshape(-1, 1) + time = Points(time, R1('t')) + points = Points(points, R3('x')) + inside = P._contains(points, time) + assert all(inside[:4]) + assert not any(inside[4:]) + + +def test_Box_boundary_volume(): + P = Box(R3('x'), [0, 2.0, 3.0], 1, 1, 1).boundary + volume = P.volume() + assert volume.item() == 6 + + +def test_Box_boundary_volume_with_variable_corners(): + P = Box(R3('x'), origin, width, height, 2.0).boundary + time = Points(torch.tensor([0, 1, 2.0]).reshape(-1, 1), R1('t')) + volume = P.volume(time) + assert all(torch.isclose(volume, torch.tensor([[16], [32.0], [52]]))) + + +def test_Box_boundary_random_sampling_with_n(): + P = Box(R3('x'), [0, 2.0, 3.0], 1, 1, 1).boundary + points = P.sample_random_uniform(n=10) + assert points.as_tensor.shape == (10, 3) + assert all(P._contains(points)) + + +def test_Box_boundary_random_sampling_with_d(): + P = Box(R3('x'), [0, 2.0, 3.0], 1, 1, 1).boundary + points = P.sample_random_uniform(d=15) + assert all(P._contains(points)) + + +def test_Box_boundary_random_sampling_with_n_and_variable_origin(): + P = Box(R3('x'), origin, 1, 1, 1).boundary + time = Points(torch.tensor([[0.0], [1.0], [2.0]]), R1('t')) + points = P.sample_random_uniform(n=10, params=time) + assert points.as_tensor.shape == (30, 3) + time = Points(torch.repeat_interleave(time, 10, dim=0), R1('t')) + assert all(P._contains(points, time)) + + +def test_Box_boundary_random_sampling_with_n_and_variable_corners(): + P = Box(R3('x'), origin, width, height, 1).boundary + time = Points(torch.tensor([[0.0], [1.0], [2.0]]), R1('t')) + points = P.sample_random_uniform(n=1, params=time) + assert points.as_tensor.shape == (3, 3) + assert all(P._contains(points, time)) + + +def test_Box_boundary_grid_sampling_with_n(): + P = Box(R3('x'), [0, 2.0, 3.0], 1, 1, 1).boundary + points = P.sample_grid(n=10) + assert points.as_tensor.shape == (10, 3) + assert all(P._contains(points)) + + +def test_Box_boundary_grid_sampling_with_d(): + P = Box(R3('x'), [0, 2.0, 3.0], 1, 1, 1).boundary + points = P.sample_grid(d=15) + assert all(P._contains(points)) + + +def test_Box_boundary_grid_sampling_with_n_and_variable_origin(): + P = Box(R3('x'), origin, 1, 1, 1).boundary + time = Points(torch.tensor([[0.0]]), R1('t')) + points = P.sample_grid(n=50, params=time) + assert points.as_tensor.shape == (50, 3) + time = Points(torch.repeat_interleave(time, 50, dim=0), R1('t')) + assert all(P._contains(points, time)) + + +def test_Box_boundary_grid_sampling_with_n_and_variable_corners(): + P = Box(R3('x'), [0, 2.0, 3.0], width, height, 1).boundary + time = Points(torch.tensor([[2.0]]), R1('t')) + points = P.sample_grid(n=100, params=time) + assert points.as_tensor.shape == (100, 3) + time = Points(torch.repeat_interleave(time, 100, dim=0), R1('t')) + assert all(P._contains(points, time)) + + +def test_Box_normals(): + P = Box(R3('x'), [0, 0.0, 0.0], 1, 1, 1).boundary + points = torch.tensor([[0.5, 0.5, 0], [0.5, 0.05, 1.0], [0, 0.5, 0.5], [1.0, 0.2, 0.7], + [0.2, 0.0, 0.2], [0.5, 1.0, 0.7]]) + points = Points(points, R3('x')) + normals = P.normal(points) + assert normals.shape == (6, 3) + expected_normals = torch.tensor([[0, 0, -1.0], [0, 0, 1.0], + [-1.0, 0, 0.0], [1.0, 0, 0], + [0, -1.0, 0], [0, 1.0, 0]]) + assert torch.all(torch.isclose(expected_normals, normals)) + + +def test_Box_normals_if_corners_change(): + P = Box(R3('x'), origin, 1, 1, 1).boundary + points = torch.tensor([[1.0, 0.5, 0.5], [1.0, 1.5, 0.5], [0.5, 0.5, 1.0]]) + points = Points(points, R3('x')) + time = Points(torch.tensor([0, 1, 0.0]).reshape(-1, 1), R1('t')) + normals = P.normal(points, time) + expected_normals = torch.tensor([[1.0, 0, 0], [-1.0, 0, 0], [0, 0, 1.0]]) + assert normals.shape == (3, 3) + one = torch.tensor(1.0) + assert all(torch.isclose(torch.linalg.norm(normals, dim=1), one, atol=0.0001)) + assert torch.all(torch.isclose(expected_normals, normals, atol=0.0001)) \ No newline at end of file diff --git a/tests/tests_domain/test_domainND_hypercube.py b/tests/tests_domain/test_domainND_hypercube.py new file mode 100644 index 00000000..19f070ba --- /dev/null +++ b/tests/tests_domain/test_domainND_hypercube.py @@ -0,0 +1,89 @@ +import pytest +import torch + +from torchphysics.problem.domains.domainND.hypercube import HyperCube +from torchphysics.problem.spaces.space import Rn +from torchphysics.problem.spaces.points import Points + + +def test_create_hypercube(): + H = HyperCube(Rn("x", 4), 0.0, 10.0) + assert "x" in H.space + assert H.dim == 4 + assert torch.all(H.lower_bounds == torch.tensor([0.0, 0.0, 0.0, 0.0])) + assert torch.all(H.upper_bounds == torch.tensor([10.0, 10.0, 10.0, 10.0])) + + +def test_create_hypercube_with_list(): + H = HyperCube(Rn("x", 2), (1.0, 2.0), 20.0) + assert "x" in H.space + assert H.dim == 2 + assert torch.all(H.lower_bounds == torch.tensor([1.0, 2.0])) + assert torch.all(H.upper_bounds == torch.tensor([20.0, 20.0])) + + +def test_create_hypercube_with_tensor(): + H = HyperCube(Rn("x", 2), (1.0, 2.0), torch.tensor([20.0, 2.5])) + assert "x" in H.space + assert H.dim == 2 + assert torch.all(H.lower_bounds == torch.tensor([1.0, 2.0])) + assert torch.all(H.upper_bounds == torch.tensor([20.0, 2.5])) + + +def test_create_hypercube_with_wrong_shapes(): + with pytest.raises(AssertionError): + _ = HyperCube(Rn("x", 4), (1.0, 2.0, 3.0), torch.tensor([20.0, 2.5, 5.0, 5.0, 5.0])) + with pytest.raises(AssertionError): + _ = HyperCube(Rn("x", 4), (1.0, 2.0, 3.0, 0.0), torch.tensor([20.0, 2.5, 5.0, 5.0, 5.0])) + + +def test_create_hypercube_with_callable(): + with pytest.raises(ValueError): + _ = HyperCube(Rn("x", 4), lambda x: x, 0.0) + + +def test_get_hypercube_volume(): + H = HyperCube(Rn("x", 2), (1.0, 2.0), 20.0) + assert H.volume() == 19*18 + + +def test_hypercube_sample_random_uniform_with_n(): + lower_bound = (1.0, 2.0, 3.0, 4.0) + upper_bound = (10.0, 11.0, 10.0, 20.0) + H = HyperCube(Rn("x", 4), lower_bound, upper_bound) + points = H.sample_random_uniform(100).as_tensor + assert points.shape == (100, 4) + for i in range(4): + assert all(points[:, i] >= lower_bound[i]) + assert all(points[:, i] <= upper_bound[i]) + + +def test_hypercube_sample_random_uniform_with_d(): + lower_bound = (1.0, 2.0, 3.0, 4.0) + upper_bound = (10.0, 11.0, 10.0, 20.0) + H = HyperCube(Rn("x", 4), lower_bound, upper_bound) + points = H.sample_random_uniform(d=1).as_tensor + for i in range(4): + assert all(points[:, i] >= lower_bound[i]) + assert all(points[:, i] <= upper_bound[i]) + + +def test_hypercube_sample_grid_with_n(): + lower_bound = (1.0, 2.0, 3.0, 4.0) + upper_bound = (10.0, 11.0, 10.0, 20.0) + H = HyperCube(Rn("x", 4), lower_bound, upper_bound) + points = H.sample_grid(100).as_tensor + assert points.shape == (100, 4) + for i in range(4): + assert all(points[:, i] >= lower_bound[i]) + assert all(points[:, i] <= upper_bound[i]) + + +def test_hypercube_sample_grid_with_d(): + lower_bound = (1.0, 2.0, 3.0, 4.0) + upper_bound = (10.0, 11.0, 10.0, 20.0) + H = HyperCube(Rn("x", 4), lower_bound, upper_bound) + points = H.sample_grid(d=1).as_tensor + for i in range(4): + assert all(points[:, i] >= lower_bound[i]) + assert all(points[:, i] <= upper_bound[i]) \ No newline at end of file diff --git a/tests/tests_functionsets/test_CustomFunctionSet.py b/tests/tests_functionsets/test_CustomFunctionSet.py new file mode 100644 index 00000000..d1f4d8a7 --- /dev/null +++ b/tests/tests_functionsets/test_CustomFunctionSet.py @@ -0,0 +1,356 @@ +import torch +import pytest + +from torchphysics.problem.spaces import R1, FunctionSpace +from torchphysics.problem.domains.functionsets import CustomFunctionSet +from torchphysics.problem.domains.functionsets.functionset_operations import FunctionSetProduct, FunctionSetCollection +from torchphysics.problem.samplers import GridSampler +from torchphysics.problem.domains.domain1D import Interval +from torchphysics.problem.spaces.points import Points +from torchphysics.utils.user_fun import UserFunction + +def test_create_custom_fn_set(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + assert fn_set.function_set_size == 100 + assert fn_set.parameter_sampler == sampler + assert fn_set.custom_fn.fun == custom_fn + + +def test_create_custom_fn_set_with_user_fn(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, UserFunction(custom_fn)) + assert fn_set.function_set_size == 100 + assert fn_set.parameter_sampler == sampler + assert fn_set.custom_fn.fun == custom_fn + + +def test_custom_fn_set_create_functions(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set.create_functions() + assert torch.is_tensor(fn_set.param_samples.as_tensor) + assert fn_set.param_samples.as_tensor.shape[0] == 100 + assert fn_set.param_samples.as_tensor.shape[1] == 1 + + +def test_custom_fn_set_get_single_fn(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + fisrt_value = sampler.sample_points().as_tensor[0] + custom_fn = lambda k,x : k + 2 + x + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set.create_functions() + fn_0 = fn_set.get_function(0) + assert callable(fn_0) + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + fn_out = fn_0(input_points) + assert fn_out.space == R1("u") + assert torch.all(fn_out.as_tensor == input_points.as_tensor + 2.0 + fisrt_value) + + +def test_custom_fn_set_get_multiple_fn(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100).make_static() + custom_fn = lambda k,x : k + 2 + x + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set.create_functions() + fn_0 = fn_set.get_function([0, 1, 2, 3]) + assert callable(fn_0) + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + fn_out = fn_0(input_points) + assert fn_out.space == R1("u") + assert fn_out.as_tensor.shape[0] == 4 + assert fn_out.as_tensor.shape[1] == 10 + for i in range(4): + fisrt_value = sampler.sample_points().as_tensor[i] + assert torch.all(torch.isclose(fn_out.as_tensor[i:i+1], input_points.as_tensor + 2.0 + fisrt_value)) + + +def test_custom_fn_set_get_multiple_fn_with_different_input(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100).make_static() + custom_fn = lambda k,x : k + 2 + x + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set.create_functions() + fn_0 = fn_set.get_function([0, 1, 2, 3]) + assert callable(fn_0) + input_points = Points(torch.rand((4, 10, 1)), R1("x")) + fn_out = fn_0(input_points) + assert fn_out.space == R1("u") + assert fn_out.as_tensor.shape[0] == 4 + assert fn_out.as_tensor.shape[1] == 10 + for i in range(4): + fisrt_value = sampler.sample_points().as_tensor[i] + assert torch.all(torch.isclose(fn_out.as_tensor[i:i+1], input_points[i:i+1].as_tensor + 2.0 + fisrt_value)) + + +def test_discretize_custom_fn_set(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + discrete_fn_set = fn_set.discretize(input_points) + assert discrete_fn_set.is_discretized + assert discrete_fn_set.is_discretization_of(fn_set) + + +def test_discretize_custom_fn_set_get_fn(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + discrete_fn_set = fn_set.discretize(input_points) + discrete_fn_set.create_functions() + fn_set_out = discrete_fn_set.get_function(0) + assert not callable(fn_set_out) + assert fn_set_out.as_tensor.shape[0] == 1 + + +def test_discretize_custom_fn_set_get_fn_multiple(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + discrete_fn_set = fn_set.discretize(input_points) + discrete_fn_set.create_functions() + fn_set_out = discrete_fn_set.get_function([0, 1, 2]) + assert not callable(fn_set_out) + assert fn_set_out.as_tensor.shape[0] == 3 + + +def test_custom_fn_set_create_product(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + space2 = FunctionSpace(R1("x"), R1("y")) + fn_set2 = CustomFunctionSet(space2, sampler, custom_fn) + fn_set *= fn_set2 + fn_set.create_functions() + + +def test_custom_fn_set_product_get_function(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + space2 = FunctionSpace(R1("x"), R1("y")) + fn_set2 = CustomFunctionSet(space2, sampler, custom_fn) + fn_set *= fn_set2 + fn_set.create_functions() + fn = fn_set.get_function([0, 1, 2]) + assert callable(fn) + assert fn_set.function_sets[0].current_idx == [0, 1, 2] + assert fn_set.function_sets[1].current_idx == [0, 1, 2] + + +def test_custom_fn_set_product_evaluate_function(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + space2 = FunctionSpace(R1("x"), R1("y")) + fn_set2 = CustomFunctionSet(space2, sampler, custom_fn) + fn_set *= fn_set2 + fn_set.create_functions() + fn = fn_set.get_function([0, 1, 2]) + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + out = fn(input_points) + assert out.as_tensor.shape[0] == 3 + assert out.as_tensor.shape[1] == 10 + assert out.as_tensor.shape[2] == 2 + + +def test_custom_fn_set_create_append(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set2 = CustomFunctionSet(space, sampler, custom_fn) + fn_set = fn_set.append(fn_set2) + fn_set.create_functions() + + +def test_custom_fn_set_append_get_function(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set2 = CustomFunctionSet(space, sampler, custom_fn) + fn_set = fn_set.append(fn_set2) + fn_set.create_functions() + fn = fn_set.get_function([0, 1, 2]) + assert callable(fn) + assert all(fn_set.current_idx == torch.tensor([0, 1, 2])) + + +def test_custom_fn_set_append_evaluate_function_first(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set2 = CustomFunctionSet(space, sampler, custom_fn) + fn_set = fn_set.append(fn_set2) + fn_set.create_functions() + fn = fn_set.get_function([0, 1, 2]) + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + out = fn(input_points) + assert out.as_tensor.shape[0] == 3 + assert out.as_tensor.shape[1] == 10 + assert out.as_tensor.shape[2] == 1 + + +def test_custom_fn_set_append_evaluate_function_both(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set2 = CustomFunctionSet(space, sampler, custom_fn) + fn_set = fn_set.append(fn_set2) + fn_set.create_functions() + fn = fn_set.get_function([0, 1, 122]) + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + out = fn(input_points) + assert out.as_tensor.shape[0] == 3 + assert out.as_tensor.shape[1] == 10 + assert out.as_tensor.shape[2] == 1 + + +def test_custom_fn_set_discretize_product(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + space2 = FunctionSpace(R1("x"), R1("y")) + fn_set2 = CustomFunctionSet(space2, sampler, custom_fn) + fn_set *= fn_set2 + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + discrete_fn = fn_set.discretize(input_points) + assert isinstance(discrete_fn, FunctionSetProduct) + + +def test_custom_fn_set_discretize_product_check_discrete(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + space2 = FunctionSpace(R1("x"), R1("y")) + fn_set2 = CustomFunctionSet(space2, sampler, custom_fn) + fn_set *= fn_set2 + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + discrete_fn = fn_set.discretize(input_points) + assert discrete_fn.is_discretized + assert not fn_set.is_discretized + + +def test_custom_fn_set_discretize_product_check_discretization_of(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + space2 = FunctionSpace(R1("x"), R1("y")) + fn_set2 = CustomFunctionSet(space2, sampler, custom_fn) + space3 = FunctionSpace(R1("x"), R1("z")) + fn_set3 = CustomFunctionSet(space3, sampler, custom_fn) + fn_set *= fn_set2 + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + discrete_fn = fn_set.discretize(input_points) + assert discrete_fn.is_discretization_of(fn_set) + assert not discrete_fn.is_discretization_of(fn_set2) + assert not discrete_fn.is_discretization_of(fn_set2*fn_set3) + + +def test_custom_fn_set_discretize_append(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set2 = CustomFunctionSet(space, sampler, custom_fn) + fn_set = fn_set.append(fn_set2) + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + discrete_fn = fn_set.discretize(input_points) + assert isinstance(discrete_fn, FunctionSetCollection) + + +def test_custom_fn_set_discretize_check_discrete(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set2 = CustomFunctionSet(space, sampler, custom_fn) + fn_set = fn_set.append(fn_set2) + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + discrete_fn = fn_set.discretize(input_points) + assert discrete_fn.is_discretized + assert not fn_set.is_discretized + + +def test_custom_fn_set_discretize_check_discretization_of(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set2 = CustomFunctionSet(space, sampler, custom_fn) + fn_set = fn_set.append(fn_set2) + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + discrete_fn = fn_set.discretize(input_points) + assert discrete_fn.is_discretization_of(fn_set) + assert not discrete_fn.is_discretization_of(fn_set2) + assert not discrete_fn.is_discretization_of(fn_set2.append(fn_set2)) + + +def test_discrete_fn_set_mean_and_std(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set.create_functions() + input_points = Points(torch.rand((1, 10, 1)), R1("x")) + discrete_fn = fn_set.discretize(input_points) + discrete_fn.compute_normalization() + assert torch.is_tensor(discrete_fn.mean) + assert torch.is_tensor(discrete_fn.std) + + +def test_discrete_fn_set_pca(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set.create_functions() + input_points = Points(torch.rand((1, 100, 1)), R1("x")) + discrete_fn = fn_set.discretize(input_points) + discrete_fn.compute_pca(10) + U, S, V = discrete_fn.pca + assert torch.is_tensor(U) + assert torch.is_tensor(S) + assert torch.is_tensor(V) + assert V.shape[0] == 100 and V.shape[1] == 10 + assert len(S) == 10 + + +def test_discrete_fn_set_pca_no_norm(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + fn_set.create_functions() + input_points = Points(torch.rand((1, 100, 1)), R1("x")) + discrete_fn = fn_set.discretize(input_points) + discrete_fn.compute_pca(10, normalize_data=False) + U, S, V = discrete_fn.pca + assert torch.is_tensor(U) + assert torch.is_tensor(S) + assert torch.is_tensor(V) + assert V.shape[0] == 100 and V.shape[1] == 10 + assert len(S) == 10 \ No newline at end of file diff --git a/tests/tests_functionsets/test_DataFunctionSet.py b/tests/tests_functionsets/test_DataFunctionSet.py new file mode 100644 index 00000000..71fb068e --- /dev/null +++ b/tests/tests_functionsets/test_DataFunctionSet.py @@ -0,0 +1,83 @@ +import torch + +from torchphysics.problem.spaces import R1, R2, FunctionSpace +from torchphysics.problem.domains.functionsets.data_functionset import DataFunctionSet + +def test_create_data_fn_set(): + data = torch.rand((500, 100, 2)) + space = FunctionSpace(R1("x"), R2("u")) + data_fn_set = DataFunctionSet(space, data) + assert data_fn_set.function_set_size == 500 + + +def test_data_fn_set_is_discrete(): + data = torch.rand((500, 100, 2)) + space = FunctionSpace(R1("x"), R2("u")) + data_fn_set = DataFunctionSet(space, data) + assert data_fn_set.is_discretized + + +def test_data_fn_set_create_fn(): + data = torch.rand((500, 100, 2)) + space = FunctionSpace(R1("x"), R2("u")) + data_fn_set = DataFunctionSet(space, data) + data_fn_set.create_functions() + + +def test_data_fn_set_get_fn(): + data = torch.rand((500, 100, 2)) + space = FunctionSpace(R1("x"), R2("u")) + data_fn_set = DataFunctionSet(space, data) + data_fn_set.create_functions() + output_fn = data_fn_set.get_function(0) + assert output_fn.space == R2("u") + assert torch.all(output_fn.as_tensor == data[0]) + + +def test_data_fn_set_get_fn_multiple(): + data = torch.rand((500, 100, 2)) + space = FunctionSpace(R1("x"), R2("u")) + data_fn_set = DataFunctionSet(space, data) + data_fn_set.create_functions() + output_fn = data_fn_set.get_function([0, 101, 32]) + assert output_fn.space == R2("u") + assert torch.all(output_fn.as_tensor[0] == data[0]) + assert torch.all(output_fn.as_tensor[1] == data[101]) + assert torch.all(output_fn.as_tensor[2] == data[32]) + + +def test_data_fn_set_product(): + data = torch.rand((500, 100, 2)) + space = FunctionSpace(R1("x"), R2("u")) + data_fn_set = DataFunctionSet(space, data) + data2 = torch.rand((500, 100, 2)) + space2 = FunctionSpace(R1("x"), R2("w")) + data_fn_set2 = DataFunctionSet(space2, data2) + data_fn_set *= data_fn_set2 + data_fn_set.create_functions() + output_fn = data_fn_set.get_function(0) + assert output_fn.space == R2("u")*R2("w") + assert output_fn.as_tensor.shape[-1] == 4 + + +def test_data_fn_set_normalize(): + data = torch.rand((500, 100, 2)) + space = FunctionSpace(R1("x"), R2("u")) + data_fn_set = DataFunctionSet(space, data) + data_fn_set.compute_normalization() + assert torch.is_tensor(data_fn_set.mean) + assert torch.is_tensor(data_fn_set.std) + + +def test_data_fn_set_pca(): + data = torch.rand((500, 100, 2)) + space = FunctionSpace(R1("x"), R2("u")) + data_fn_set = DataFunctionSet(space, data) + data_fn_set.compute_pca(4) + U, S, V = data_fn_set.pca + assert torch.is_tensor(U) + assert torch.is_tensor(S) + assert torch.is_tensor(V) + assert V.shape[0] == 200 and V.shape[1] == 4 + assert len(S) == 4 + data_fn_set.compute_pca(4, normalize_data=False) \ No newline at end of file diff --git a/tests/tests_functionsets/test_FunctionSetMain.py b/tests/tests_functionsets/test_FunctionSetMain.py deleted file mode 100644 index 9dad74cb..00000000 --- a/tests/tests_functionsets/test_FunctionSetMain.py +++ /dev/null @@ -1,162 +0,0 @@ -import torch -import pytest - -from torchphysics.problem.conditions import * -from torchphysics.problem.spaces import R1, FunctionSpace -from torchphysics.problem.domains import Interval, FunctionSet, CustomFunctionSet -from torchphysics.problem.domains.functionsets.functionset import FunctionSetCollection -from torchphysics.problem.samplers import GridSampler -from torchphysics.utils.user_fun import UserFunction - - -def create_inputs(): - # Parameter space - K = R1('k') - I_k = Interval(K, 0, 4) - # Function space - T = R1('t') - I_t = Interval(T, 0, 4) - fn_space = FunctionSpace(I_t, R1('f')) - return fn_space, I_k - - -def test_create_function_set(): - fn_space, I_k = create_inputs() - p_sampler = GridSampler(I_k, 500) - fn_set = FunctionSet(fn_space, p_sampler) - assert fn_set.function_space == fn_space - assert fn_set.parameter_sampler == p_sampler - assert fn_set.current_iteration_num == -1 - assert fn_set.param_batch is None - - -def test_len_of_function_set(): - fn_space, I_k = create_inputs() - p_sampler = GridSampler(I_k, 500) - fn_set = FunctionSet(fn_space, p_sampler) - assert len(fn_set) == len(p_sampler) - - -def test_function_set_sample_params(): - fn_space, I_k = create_inputs() - p_sampler = GridSampler(I_k, 500) - fn_set = FunctionSet(fn_space, p_sampler) - fn_set.sample_params() - assert len(fn_set.param_batch) == 500 - - -def test_create_meshgrid(): - fn_space, I_k = create_inputs() - p_sampler = GridSampler(I_k, 50) - fn_set = FunctionSet(fn_space, p_sampler) - t_sampler = GridSampler(fn_space.input_domain, 10) - fn_set.sample_params() - meshgrid = fn_set._create_meshgrid(t_sampler.sample_points()) - assert meshgrid.shape == (50, 10) - assert 'k' in meshgrid.space - assert 't' in meshgrid.space - # check correct shape and distribution - tensor = meshgrid.as_tensor - assert tensor.shape == (50, 10, 2) - for i in range(1, 10): - assert tensor[0, 0, 0] == tensor[0, i, 0] - - -def test_add_functions_sets(): - fn_space, I_k = create_inputs() - p_sampler = GridSampler(I_k, 500) - fn_set = FunctionSet(fn_space, p_sampler) - p_sampler2 = GridSampler(I_k, 50) - fn_set2 = FunctionSet(fn_space, p_sampler2) - assert isinstance(fn_set + fn_set2, FunctionSetCollection) - - -def test_can_not_add_set_in_different_spaces(): - fn_space, I_k = create_inputs() - p_sampler = GridSampler(I_k, 500) - fn_set = FunctionSet(fn_space, p_sampler) - p_sampler2 = GridSampler(I_k, 50) - fn_set2 = FunctionSet(FunctionSpace(I_k, R1('w')), p_sampler2) - with pytest.raises(AssertionError): - fn_set2 + fn_set - - -def test_multiple_add(): - fn_space, I_k = create_inputs() - p_sampler = GridSampler(I_k, 500) - fn_set = FunctionSet(fn_space, p_sampler) - p_sampler2 = GridSampler(I_k, 50) - fn_set2 = FunctionSet(fn_space, p_sampler2) - fn_set3 = FunctionSet(fn_space, p_sampler2) - fn_collect = (fn_set + fn_set2) + fn_set3 - assert len(fn_collect.collection) == 3 - fn_collect = fn_set3 + (fn_set + fn_set2) - assert len(fn_collect.collection) == 3 - - -def test_len_of_function_set_collection(): - fn_space, I_k = create_inputs() - p_sampler = GridSampler(I_k, 500) - fn_set = FunctionSet(fn_space, p_sampler) - p_sampler2 = GridSampler(I_k, 50) - fn_set2 = FunctionSet(fn_space, p_sampler2) - fn_set3 = FunctionSet(fn_space, p_sampler2) - fn_collect = fn_set + fn_set2 - assert len(fn_collect) == 550 - fn_collect += fn_set3 - assert len(fn_collect) == 600 - fn_collect += (fn_set3 + fn_set) - assert len(fn_collect) == 1150 - - -def test_sample_params_in_collection(): - fn_space, I_k = create_inputs() - p_sampler = GridSampler(I_k, 500) - fn_set = FunctionSet(fn_space, p_sampler) - p_sampler2 = GridSampler(I_k, 50) - fn_set2 = FunctionSet(fn_space, p_sampler2) - fn_collect = fn_set + fn_set2 - fn_collect.sample_params() - assert len(fn_set.param_batch) == 500 - assert len(fn_set2.param_batch) == 50 - - -def test_custom_function_set(): - def f(k, t): - return k*t - fn_space, I_k = create_inputs() - p_sampler = GridSampler(I_k, 500) - fn_set = CustomFunctionSet(fn_space, p_sampler, f) - assert fn_set.function_space == fn_space - assert fn_set.parameter_sampler == p_sampler - assert fn_set.current_iteration_num == -1 - assert fn_set.param_batch is None - assert isinstance(fn_set.custom_fn, UserFunction) - - -def test_evaluate_custom_function_set(): - def f(k, t): - return k*t - fn_space, I_k = create_inputs() - p_sampler = GridSampler(I_k, 500) - fn_set = CustomFunctionSet(fn_space, p_sampler, f) - fn_set.sample_params() - t_sampler = GridSampler(fn_space.input_domain, 10) - fn_batch = fn_set.create_function_batch(t_sampler.sample_points()).as_tensor - assert fn_batch.shape == (500, 10, 1) - - -def test_evaluate_custom_function_set_collection(): - def f(k, t): - return k*t - fn_space, I_k = create_inputs() - p_sampler = GridSampler(I_k, 500) - fn_set = CustomFunctionSet(fn_space, p_sampler, f) - def f2(k, t): - return k*torch.sin(t**2) - p_sampler2 = GridSampler(I_k, 20) - fn_set += CustomFunctionSet(fn_space, p_sampler2, UserFunction(f2)) - fn_set.sample_params() - t_sampler = GridSampler(fn_space.input_domain, 22) - fn_batch = fn_set.create_function_batch(t_sampler.sample_points()).as_tensor - assert fn_batch.shape == (520, 22, 1) \ No newline at end of file diff --git a/tests/tests_functionsets/test_FunctionSetTransforms.py b/tests/tests_functionsets/test_FunctionSetTransforms.py new file mode 100644 index 00000000..89ec97ca --- /dev/null +++ b/tests/tests_functionsets/test_FunctionSetTransforms.py @@ -0,0 +1,186 @@ +import torch +import pytest + +from torchphysics.problem.domains.functionsets import FunctionSet +from torchphysics.problem.domains.functionsets.functionset_operations import ( + FunctionSetAdd, FunctionSetSubstract, FunctionSetTransform + ) +from torchphysics.problem.spaces import R1, R2, FunctionSpace, Points +from torchphysics.problem.domains.functionsets import CustomFunctionSet +from torchphysics.problem.samplers import GridSampler +from torchphysics.problem.domains.domain1D import Interval +from torchphysics.problem.spaces.points import Points +from torchphysics.utils.user_fun import UserFunction + + +def test_create_fn_set_sum(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + fn_set2 = FunctionSet(space, 100) + fn_set += fn_set2 + assert isinstance(fn_set, FunctionSetAdd) + assert fn_set.function_space == space + assert fn_set.function_set_size == 100 + + +def test_create_fn_set_sum_multiple(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + fn_set2 = FunctionSet(space, 100) + fn_set += fn_set2 + fn_set3 = FunctionSet(space, 100) + fn_set4 = fn_set + fn_set3 + assert isinstance(fn_set4, FunctionSetAdd) + assert fn_set4.function_space == space + assert fn_set4.function_set_size == 100 + + fn_set4 = fn_set3 + fn_set + assert isinstance(fn_set4, FunctionSetAdd) + assert fn_set4.function_space == space + assert fn_set4.function_set_size == 100 + + fn_set5 = fn_set + fn_set4 + assert isinstance(fn_set5, FunctionSetAdd) + assert fn_set5.function_space == space + assert fn_set5.function_set_size == 100 + + +def test_create_fn_set_substract(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + fn_set2 = FunctionSet(space, 100) + fn_set -= fn_set2 + assert isinstance(fn_set, FunctionSetSubstract) + assert fn_set.function_space == space + assert fn_set.function_set_size == 100 + + +def test_create_fn_set_sum_and_substract(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + fn_set2 = FunctionSet(space, 100) + fn_set += fn_set2 + fn_set3 = FunctionSet(space, 100) + fn_set4 = fn_set + fn_set3 + assert isinstance(fn_set4, FunctionSetAdd) + assert fn_set4.function_space == space + assert fn_set4.function_set_size == 100 + + fn_set4 = fn_set3 - fn_set + assert isinstance(fn_set4, FunctionSetSubstract) + assert fn_set4.function_space == space + assert fn_set4.function_set_size == 100 + + +def make_fnsets(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + fn_set = CustomFunctionSet(space, sampler, custom_fn) + + custom_fn2 = lambda k,x : torch.sin(k*x) + x*k + fn_set2 = CustomFunctionSet(space, sampler, custom_fn2) + return fn_set, fn_set2 + +def test_fn_set_sum_discrete(): + fn_set, fn_set2 = make_fnsets() + fn_set += fn_set2 + assert not fn_set.is_discretized + + +def test_fn_set_sum_make_discrete(): + fn_set, fn_set2 = make_fnsets() + fn_set += fn_set2 + gridpoints = Points(torch.tensor([0, 0.5, 1.0]).reshape(1, -1, 1), R1("x")) + fn_set_discrete = fn_set.discretize(gridpoints) + assert fn_set_discrete.is_discretized + + +def test_fn_set_substract_make_discrete(): + fn_set, fn_set2 = make_fnsets() + fn_set -= fn_set2 + gridpoints = Points(torch.tensor([0, 0.5, 1.0]).reshape(1, -1, 1), R1("x")) + fn_set_discrete = fn_set.discretize(gridpoints) + assert fn_set_discrete.is_discretized + + +def test_fn_set_sum_discretization_of(): + fn_set, fn_set2 = make_fnsets() + fn_set += fn_set2 + gridpoints = Points(torch.tensor([0, 0.5, 1.0]).reshape(1, -1, 1), R1("x")) + fn_set_discrete = fn_set.discretize(gridpoints) + assert fn_set_discrete.is_discretization_of(fn_set) + assert not fn_set_discrete.is_discretization_of(fn_set2) + + +def test_fn_set_sum_create_fns(): + fn_set, fn_set2 = make_fnsets() + fn_set += fn_set2 + fn_set.create_functions() + + +def test_fn_set_sum_get_fns(): + fn_set, fn_set2 = make_fnsets() + fn_set += fn_set2 + fn_set.create_functions() + eval_fn = fn_set.get_function([1, 2, 3]) + gridpoints = Points(torch.tensor([0, 0.5, 1.0]).reshape(1, -1, 1), R1("x")) + assert eval_fn(gridpoints).as_tensor.shape == (3, 3, 1) + + +def test_fn_set_sum_get_fns_discrete(): + fn_set, fn_set2 = make_fnsets() + fn_set += fn_set2 + gridpoints = Points(torch.tensor([0, 0.5, 1.0]).reshape(1, -1, 1), R1("x")) + fn_set_discrete = fn_set.discretize(gridpoints) + fn_set_discrete.create_functions() + eval_fn = fn_set_discrete.get_function([1, 2, 3]) + assert eval_fn.as_tensor.shape == (3, 3, 1) + + +def test_fn_set_substract_get_fns(): + fn_set, fn_set2 = make_fnsets() + fn_set -= fn_set2 + fn_set.create_functions() + eval_fn = fn_set.get_function([1, 2, 3]) + gridpoints = Points(torch.tensor([0, 0.5, 1.0]).reshape(1, -1, 1), R1("x")) + assert eval_fn(gridpoints).as_tensor.shape == (3, 3, 1) + + +def test_fn_set_transform_create(): + fn_set, _ = make_fnsets() + transform_set = FunctionSetTransform(fn_set, lambda u : torch.clamp(u, 0.0, 0.1)) + assert transform_set.fn_set == fn_set + assert callable(transform_set.transformation) + + +def test_fn_set_transform_discrete(): + fn_set, _ = make_fnsets() + transform_set = FunctionSetTransform(fn_set, lambda u : torch.clamp(u, 0.0, 0.1)) + assert not transform_set.is_discretized + gridpoints = Points(torch.tensor([0, 0.5, 1.0]).reshape(1, -1, 1), R1("x")) + set_discrete = transform_set.discretize(gridpoints) + assert set_discrete.is_discretization_of(transform_set) + assert set_discrete.is_discretization_of(fn_set) + + +def test_fn_set_transform_evaluate_fn(): + fn_set, _ = make_fnsets() + transform_set = FunctionSetTransform(fn_set, lambda u : torch.clamp(u, 0.0, 0.1)) + transform_set.create_functions() + some_fns = transform_set.get_function([3, 4, 5, 6, 10]) + gridpoints = Points(torch.tensor([0, 0.5, 1.0]).reshape(1, -1, 1), R1("x")) + output = some_fns(gridpoints).as_tensor + assert torch.all(output >= 0.0) + assert torch.all(output <= 0.1) + + +def test_fn_set_transform_evaluate_fn_discrete(): + fn_set, _ = make_fnsets() + transform_set = FunctionSetTransform(fn_set, lambda u : torch.clamp(u, 0.0, 0.1)) + gridpoints = Points(torch.tensor([0, 0.5, 1.0]).reshape(1, -1, 1), R1("x")) + set_discrete = transform_set.discretize(gridpoints) + set_discrete.create_functions() + output = set_discrete.get_function([3, 4, 5, 6, 10]).as_tensor + assert torch.all(output >= 0.0) + assert torch.all(output <= 0.1) \ No newline at end of file diff --git a/tests/tests_functionsets/test_FunctionSet_base.py b/tests/tests_functionsets/test_FunctionSet_base.py new file mode 100644 index 00000000..5288ea7a --- /dev/null +++ b/tests/tests_functionsets/test_FunctionSet_base.py @@ -0,0 +1,169 @@ +import torch +import pytest + +from torchphysics.problem.domains.functionsets import FunctionSet +from torchphysics.problem.spaces import R1, R2, FunctionSpace, Points + +def test_create_fn_set(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + assert fn_set.function_space == space + assert fn_set.function_set_size == 100 + + +def test_fn_set_not_discrete(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + assert not fn_set.is_discretized + + +def test_fn_set_discretize(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + points = Points(torch.rand((1, 100, 1)), R1("t")) + _ = fn_set.discretize(points) + + +def test_fn_set_discretization_of_default_wrong(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + assert not fn_set.is_discretization_of(None) + + +def test_fn_set_discretization_of(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + points = Points(torch.rand((1, 100, 1)), R1("t")) + discrete_fn_set = fn_set.discretize(points) + assert discrete_fn_set.is_discretization_of(fn_set) + + +def test_discrete_fn_set_is_discrete(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + points = Points(torch.rand((1, 100, 1)), R1("t")) + discrete_fn_set = fn_set.discretize(points) + assert discrete_fn_set.is_discretized + + +def test_fn_set_product(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + space2 = FunctionSpace(R1("t"), R2("y")) + fn_set2 = FunctionSet(space2, 100) + new_fn_set = fn_set * fn_set2 + assert new_fn_set.function_space.output_space == R2("x")*R2("y") + assert new_fn_set.function_space.input_space == R1("t") + + +def test_fn_set_product_different_input(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + space2 = FunctionSpace(R1("x"), R2("y")) + fn_set2 = FunctionSet(space2, 100) + new_fn_set = fn_set * fn_set2 + assert new_fn_set.function_space.output_space == R2("x")*R2("y") + assert new_fn_set.function_space.input_space == R1("t")*R1("x") + + +def test_fn_set_product_same_output(): + space = FunctionSpace(R1("t"), R2("u")) + fn_set = FunctionSet(space, 100) + space2 = FunctionSpace(R1("x"), R2("u")) + fn_set2 = FunctionSet(space2, 100) + with pytest.raises(AssertionError): + _ = fn_set * fn_set2 + + +def test_fn_set_product_three_times(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + space2 = FunctionSpace(R1("t"), R2("y")) + fn_set2 = FunctionSet(space2, 100) + space3 = FunctionSpace(R1("t"), R1("z")) + fn_set3 = FunctionSet(space3, 100) + new_fn_set = fn_set * fn_set2 + new_fn_set = new_fn_set*fn_set3 + assert new_fn_set.function_space.output_space == R2("x")*R2("y")*R1("z") + assert new_fn_set.function_space.input_space == R1("t") + assert new_fn_set.function_set_size == 100 + + new_fn_set = fn_set * fn_set2 + new_fn_set = fn_set3*new_fn_set + assert new_fn_set.function_space.output_space == R2("x")*R2("y")*R1("z") + assert new_fn_set.function_space.input_space == R1("t") + assert new_fn_set.function_set_size == 100 + + +def test_fn_set_product_with_product(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + space2 = FunctionSpace(R1("t"), R2("y")) + fn_set2 = FunctionSet(space2, 100) + space3 = FunctionSpace(R1("t"), R1("z")) + fn_set3 = FunctionSet(space3, 100) + space4 = FunctionSpace(R1("w"), R1("f")) + fn_set4 = FunctionSet(space4, 100) + + new_fn_set = fn_set * fn_set2 + new_fn_set2 = fn_set3 * fn_set4 + new_fn_set *= new_fn_set2 + assert new_fn_set.function_space.output_space == R2("x")*R2("y")*R1("z")*R1("f") + assert new_fn_set.function_space.input_space == R1("t")*R1("w") + assert new_fn_set.function_set_size == 100 + + new_fn_set = fn_set * fn_set2 + new_fn_set2 = fn_set3 * fn_set4 + new_fn_set2 *= new_fn_set + assert new_fn_set2.function_space.output_space == R1("z")*R1("f")*R2("x")*R2("y") + assert new_fn_set2.function_space.input_space == R1("t")*R1("w") + assert new_fn_set2.function_set_size == 100 + + +def test_fn_set_append_wrong_output_space(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + space2 = FunctionSpace(R1("t"), R2("y")) + fn_set2 = FunctionSet(space2, 100) + with pytest.raises(AssertionError): + _ = fn_set.append(fn_set2) + + +def test_fn_set_append(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + space2 = FunctionSpace(R1("t"), R2("x")) + fn_set2 = FunctionSet(space2, 100) + new_fn_set = fn_set.append(fn_set2) + assert new_fn_set.function_space.output_space == R2("x") + assert new_fn_set.function_set_size == 200 + + +def test_fn_set_append_two_times(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + space2 = FunctionSpace(R1("t"), R2("x")) + fn_set2 = FunctionSet(space2, 100) + space3 = FunctionSpace(R1("t"), R2("x")) + fn_set3 = FunctionSet(space3, 100) + new_fn_set = fn_set.append(fn_set2).append(fn_set3) + assert new_fn_set.function_space.output_space == R2("x") + assert new_fn_set.function_set_size == 300 + + +def test_fn_set_append_two_combies(): + space = FunctionSpace(R1("t"), R2("x")) + fn_set = FunctionSet(space, 100) + space2 = FunctionSpace(R1("t"), R2("x")) + fn_set2 = FunctionSet(space2, 100) + space3 = FunctionSpace(R1("t"), R2("x")) + fn_set3 = FunctionSet(space3, 100) + space4 = FunctionSpace(R1("t"), R2("x")) + fn_set4 = FunctionSet(space4, 100) + + new_fn_set = fn_set.append(fn_set2) + new_fn_set2 = fn_set4.append(fn_set3) + new_fn_set = new_fn_set.append(new_fn_set2) + assert new_fn_set.function_space.output_space == R2("x") + assert new_fn_set.function_space.input_space == R1("t") + assert new_fn_set.function_set_size == 400 \ No newline at end of file diff --git a/tests/tests_functionsets/test_GRFFunctionSet.py b/tests/tests_functionsets/test_GRFFunctionSet.py new file mode 100644 index 00000000..9370da20 --- /dev/null +++ b/tests/tests_functionsets/test_GRFFunctionSet.py @@ -0,0 +1,135 @@ +import torch +import pytest +import math + +from torchphysics.problem.spaces import R1, R2, FunctionSpace +from torchphysics.problem.domains.functionsets.grf_functionset import GRFFunctionSet + + +def test_create_grf_fn_set(): + X = R1("x") + U = R1("u") + fn_space = FunctionSpace(X, U) + _ = GRFFunctionSet(fn_space, 100, 512) + + +def test_create_grf_fn_set_2D(): + X = R2("x") + U = R1("u") + fn_space = FunctionSpace(X, U) + _ = GRFFunctionSet(fn_space, 100, (512, 512)) + + +def test_create_grf_fn_set_wrong_dimension(): + X = R2("x") + U = R1("u") + fn_space = FunctionSpace(X, U) + with pytest.raises(AssertionError): + _ = GRFFunctionSet(fn_space, 100, 512) + + +def test_grf_is_discrete(): + X = R2("x") + U = R1("u") + fn_space = FunctionSpace(X, U) + grf_fn_set = GRFFunctionSet(fn_space, 100, (512, 512)) + assert grf_fn_set.is_discretized + + +def test_create_grf(): + X = R1("x") + U = R1("u") + fn_space = FunctionSpace(X, U) + grf_fn_set = GRFFunctionSet(fn_space, 100, 512) + grf_fn_set.create_functions() + assert torch.is_tensor(grf_fn_set.grf) + assert grf_fn_set.grf.shape[0] == 100 + assert grf_fn_set.grf.shape[1] == 512 + assert grf_fn_set.grf.shape[2] == 1 + + +def test_create_grf_no_normalize(): + X = R1("x") + U = R1("u") + fn_space = FunctionSpace(X, U) + grf_fn_set = GRFFunctionSet(fn_space, 100, 16, + normalize=False, sample_noise_in_fourier_space=False) + grf_fn_set.create_functions() + assert grf_fn_set.grf.shape[0] == 100 + assert grf_fn_set.grf.shape[1] == 16 + assert grf_fn_set.grf.shape[2] == 1 + + +def test_create_grf_2D(): + X = R2("x") + U = R1("u") + fn_space = FunctionSpace(X, U) + grf_fn_set = GRFFunctionSet(fn_space, 100, (64, 64), flatten=False) + grf_fn_set.create_functions() + assert grf_fn_set.grf.shape[0] == 100 + assert grf_fn_set.grf.shape[1] == 64 + assert grf_fn_set.grf.shape[2] == 64 + assert grf_fn_set.grf.shape[3] == 1 + + +def test_create_grf_2D_flatten(): + X = R2("x") + U = R1("u") + fn_space = FunctionSpace(X, U) + grf_fn_set = GRFFunctionSet(fn_space, 100, (64, 64), flatten=True) + grf_fn_set.create_functions() + assert grf_fn_set.grf.shape[0] == 100 + assert grf_fn_set.grf.shape[1] == 64*64 + assert grf_fn_set.grf.shape[2] == 1 + + +def test_create_grf_custom_conv_fn(): + X = R2("x") + U = R1("u") + fn_space = FunctionSpace(X, U) + def conv_fn(x): + return 1/(1.0 + 0.9*math.sqrt(abs(x[0])) + 0.9*abs(x[1])**2)**2 + grf_fn_set = GRFFunctionSet(fn_space, 100, (64, 64), flatten=False, auto_cov_fn=conv_fn) + grf_fn_set.create_functions() + assert grf_fn_set.grf.shape[0] == 100 + assert grf_fn_set.grf.shape[1] == 64 + assert grf_fn_set.grf.shape[2] == 64 + assert grf_fn_set.grf.shape[3] == 1 + + +def test_get_grf(): + X = R1("x") + U = R1("u") + fn_space = FunctionSpace(X, U) + grf_fn_set = GRFFunctionSet(fn_space, 100, 512) + grf_fn_set.create_functions() + random_field = grf_fn_set.get_function([0, 12]).as_tensor + assert torch.is_tensor(random_field) + assert random_field.shape[0] == 2 + assert random_field.shape[1] == 512 + assert random_field.shape[2] == 1 + + +def test_grf_normalized(): + X = R2("x") + U = R1("u") + fn_space = FunctionSpace(X, U) + grf_fn_set = GRFFunctionSet(fn_space, 100, (64, 64), flatten=False) + grf_fn_set.compute_normalization() + assert torch.is_tensor(grf_fn_set.mean) + assert torch.is_tensor(grf_fn_set.std) + + +def test_grf_pca(): + X = R2("x") + U = R1("u") + fn_space = FunctionSpace(X, U) + grf_fn_set = GRFFunctionSet(fn_space, 100, (64, 64), flatten=False) + grf_fn_set.compute_pca(3) + U, S, V = grf_fn_set.pca + assert torch.is_tensor(U) + assert torch.is_tensor(S) + assert torch.is_tensor(V) + assert V.shape[0] == 64*64 and V.shape[1] == 3 + assert len(S) == 3 + grf_fn_set.compute_pca(4, normalize_data=False) \ No newline at end of file diff --git a/tests/tests_functionsets/test_HarmonicFunctionSet.py b/tests/tests_functionsets/test_HarmonicFunctionSet.py new file mode 100644 index 00000000..d97b4000 --- /dev/null +++ b/tests/tests_functionsets/test_HarmonicFunctionSet.py @@ -0,0 +1,143 @@ +import torch + +from torchphysics.problem.spaces import R1, R2, R3, FunctionSpace, Points +from torchphysics.problem.domains.functionsets.harmonic_functionset import ( + HarmonicFunctionSet1D, HarmonicFunctionSet2D, HarmonicFunctionSet3D +) + +def test_create_harmonic_fn_set_1D(): + T = R1("t") + U = R1("u") + Fn_space = FunctionSpace(T, U) + harmonic_fns = HarmonicFunctionSet1D(Fn_space, 1000, 3, 5) + assert harmonic_fns.period_len == 3 + assert harmonic_fns.max_frequence == 5 + + +def test_harmonic_fn_set_1D_build_functions(): + T = R1("t") + U = R1("u") + Fn_space = FunctionSpace(T, U) + harmonic_fns = HarmonicFunctionSet1D(Fn_space, 1000, 3, 5) + harmonic_fns.create_functions() + assert torch.is_tensor(harmonic_fns.fourier_coefficients) + assert harmonic_fns.fourier_coefficients.shape[0] == 1000 + assert harmonic_fns.fourier_coefficients.shape[1] == 6 + assert harmonic_fns.fourier_coefficients.shape[2] == 2 + + +def test_harmonic_fn_set_1D_get_functions(): + T = R1("t") + U = R1("u") + Fn_space = FunctionSpace(T, U) + harmonic_fns = HarmonicFunctionSet1D(Fn_space, 1000, 3, 5) + harmonic_fns.create_functions() + fn = harmonic_fns.get_function([1, 2, 3, 4, 5]) + assert callable(fn) + fn_out = fn(Points(torch.rand((1, 100, 1)), T)).as_tensor + assert torch.is_tensor(fn_out) + assert fn_out.shape[0] == 5 + assert fn_out.shape[1] == 100 + assert fn_out.shape[2] == 1 + + fn_out = fn(Points(torch.rand((5, 100, 1)), T)).as_tensor + assert torch.is_tensor(fn_out) + assert fn_out.shape[0] == 5 + assert fn_out.shape[1] == 100 + assert fn_out.shape[2] == 1 + + +def test_create_harmonic_fn_set_2D(): + T = R2("t") + U = R1("u") + Fn_space = FunctionSpace(T, U) + harmonic_fns = HarmonicFunctionSet2D(Fn_space, 1000, (3, 3), (2, 2)) + assert harmonic_fns.period_len == (3, 3) + assert harmonic_fns.max_frequence == (2, 2) + + +def test_harmonic_fn_set_2D_build_functions(): + T = R2("t") + U = R1("u") + Fn_space = FunctionSpace(T, U) + harmonic_fns = HarmonicFunctionSet2D(Fn_space, 1000, (3, 3), (6, 2)) + harmonic_fns.create_functions() + assert torch.is_tensor(harmonic_fns.fourier_coefficients) + assert harmonic_fns.fourier_coefficients.shape[0] == 1000 + assert harmonic_fns.fourier_coefficients.shape[1] == 7 + assert harmonic_fns.fourier_coefficients.shape[2] == 3 + assert harmonic_fns.fourier_coefficients.shape[3] == 4 + + +def test_harmonic_fn_set_2D_get_functions(): + T = R2("t") + U = R1("u") + Fn_space = FunctionSpace(T, U) + harmonic_fns = HarmonicFunctionSet2D(Fn_space, 1000, (3, 3), (2, 5)) + harmonic_fns.create_functions() + fn = harmonic_fns.get_function([1, 2, 3, 4, 5]) + assert callable(fn) + fn_out = fn(Points(torch.rand((1, 100, 2)), T)).as_tensor + assert torch.is_tensor(fn_out) + assert fn_out.shape[0] == 5 + assert fn_out.shape[1] == 100 + assert fn_out.shape[2] == 1 + + fn_out = fn(Points(torch.rand((5, 100, 2)), T)).as_tensor + assert torch.is_tensor(fn_out) + assert fn_out.shape[0] == 5 + assert fn_out.shape[1] == 100 + assert fn_out.shape[2] == 1 + + fn_out = fn(Points(torch.rand((5, 16, 16, 2)), T)).as_tensor + assert torch.is_tensor(fn_out) + assert fn_out.shape[0] == 5 + assert fn_out.shape[1] == 16 + assert fn_out.shape[2] == 16 + assert fn_out.shape[3] == 1 + + + +def test_create_harmonic_fn_set_3D(): + T = R3("t") + U = R1("u") + Fn_space = FunctionSpace(T, U) + harmonic_fns = HarmonicFunctionSet3D(Fn_space, 1000, (3, 3, 3), (6, 2, 1)) + assert harmonic_fns.period_len == (3, 3, 3) + assert harmonic_fns.max_frequence == (6, 2, 1) + + +def test_harmonic_fn_set_3D_build_functions(): + T = R3("t") + U = R1("u") + Fn_space = FunctionSpace(T, U) + harmonic_fns = HarmonicFunctionSet3D(Fn_space, 1000, (3, 3, 3), (6, 2, 1)) + harmonic_fns.create_functions() + assert torch.is_tensor(harmonic_fns.fourier_coefficients) + assert harmonic_fns.fourier_coefficients.shape[0] == 1000 + assert harmonic_fns.fourier_coefficients.shape[1] == 7 + assert harmonic_fns.fourier_coefficients.shape[2] == 3 + assert harmonic_fns.fourier_coefficients.shape[3] == 2 + assert harmonic_fns.fourier_coefficients.shape[4] == 8 + + +def test_harmonic_fn_set_3D_get_functions(): + T = R3("t") + U = R1("u") + Fn_space = FunctionSpace(T, U) + harmonic_fns = HarmonicFunctionSet3D(Fn_space, 1000, (3, 3, 3), (2, 5, 3)) + harmonic_fns.create_functions() + fn = harmonic_fns.get_function([1, 2, 3, 4, 5]) + assert callable(fn) + fn_out = fn(Points(torch.rand((1, 100, 3)), T)).as_tensor + assert torch.is_tensor(fn_out) + assert fn_out.shape[0] == 5 + assert fn_out.shape[1] == 100 + assert fn_out.shape[2] == 1 + + fn_out = fn(Points(torch.rand((5, 100, 3)), T)).as_tensor + assert torch.is_tensor(fn_out) + assert fn_out.shape[0] == 5 + assert fn_out.shape[1] == 100 + assert fn_out.shape[2] == 1 + \ No newline at end of file diff --git a/tests/tests_models/test_deep_o_net.py b/tests/tests_models/test_deep_o_net.py index aabf0f20..a0c38a09 100644 --- a/tests/tests_models/test_deep_o_net.py +++ b/tests/tests_models/test_deep_o_net.py @@ -1,7 +1,7 @@ import torch import pytest -from torchphysics.models.deeponet.branchnets import (BranchNet, FCBranchNet, ConvBranchNet1D) +from torchphysics.models.deeponet.branchnets import (BranchNet, FCBranchNet, ConvBranchNet) from torchphysics.models.deeponet.trunknets import (TrunkNet, FCTrunkNet) from torchphysics.models.deeponet.deeponet import DeepONet from torchphysics.models.deeponet.layers import TrunkLinear @@ -15,21 +15,16 @@ """ def test_create_trunk_net(): - net = TrunkNet(input_space=R2('x')) + default_grid = torch.rand((1, 100, 2)) + net = TrunkNet(input_space=R2('x'), default_trunk_input=default_grid) assert net.input_space == R2('x') assert net.output_space == None assert net.output_neurons == 0 def test_create_fc_trunk_net(): - net = FCTrunkNet(input_space=R2('x')) - assert net.input_space == R2('x') - assert net.output_space == None - assert net.output_neurons == 0 - - -def test_forward_fc_trunk_net(): - net = FCTrunkNet(input_space=R2('x')) + default_grid = torch.rand((1, 100, 2)) + net = FCTrunkNet(input_space=R2('x'), default_trunk_input=default_grid) assert net.input_space == R2('x') assert net.output_space == None assert net.output_neurons == 0 @@ -40,54 +35,34 @@ def test_forward_fc_trunk_net(): def helper_fn_set(): def f(k, t): return k*t - inter = Interval(R1('t'), 0, 1) params = Interval(R1('k'), 0, 1) - fn_space = FunctionSpace(inter, R1('e')) + fn_space = FunctionSpace(R1('t'), R1('e')) fn_set = CustomFunctionSet(fn_space, GridSampler(params, 20), f) return fn_space, fn_set def test_create_branch_net(): fn_space, _ = helper_fn_set() - sampler = GridSampler(fn_space.input_domain, 10).make_static() - net = BranchNet(fn_space, discretization_sampler=sampler) - assert net.discretization_sampler == sampler - assert net.input_dim == 10 + net = BranchNet(fn_space, grid=torch.rand((1, 10, 1))) assert net.input_space == fn_space def test_create_fc_branch_net(): fn_space, _ = helper_fn_set() - sampler = GridSampler(fn_space.input_domain, 15).make_static() - net = FCBranchNet(fn_space, discretization_sampler=sampler) - assert net.discretization_sampler == sampler - assert net.input_dim == 15 + net = FCBranchNet(fn_space, grid=torch.rand((1, 15, 1))) 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_set(): fn_space, fn_set = helper_fn_set() - sampler = GridSampler(fn_space.input_domain, 15).make_static() - net = FCBranchNet(fn_space, discretization_sampler=sampler) + net = FCBranchNet(fn_space, grid=torch.rand((1, 15, 1))) net.finalize(R1('u'), 20) net.fix_input(fn_set) def test_fix_branch_wrong_input(): fn_space, _ = helper_fn_set() - sampler = GridSampler(fn_space.input_domain, 15).make_static() - net = FCBranchNet(fn_space, discretization_sampler=sampler) + net = FCBranchNet(fn_space, grid=torch.rand((1, 15, 1))) with pytest.raises(NotImplementedError): net.fix_input(34) @@ -95,10 +70,10 @@ def test_fix_branch_wrong_input(): Tests for DeepONet: """ def test_create_deeponet(): - trunk = TrunkNet(input_space=R1('t')) + default_grid = torch.rand((1, 100, 1)) + trunk = TrunkNet(input_space=R1('t'), default_trunk_input=default_grid) fn_space, _ = helper_fn_set() - sampler = GridSampler(fn_space.input_domain, 15).make_static() - branch = FCBranchNet(fn_space, discretization_sampler=sampler) + branch = FCBranchNet(fn_space, grid=default_grid) net = DeepONet(trunk, branch, output_space=R1('u'), output_neurons=20) assert net.trunk == trunk assert net.branch == branch @@ -111,11 +86,11 @@ def test_create_deeponet(): def test_create_deeponet_with_seq_trunk(): - trunk = TrunkNet(input_space=R1('t')) - seq_trunk = Sequential(NormalizationLayer(Interval(R1('t'), 0, 1)), trunk) + default_grid = torch.rand((1, 100, 1)) + trunk = TrunkNet(input_space=R1('t'), default_trunk_input=default_grid) fn_space, _ = helper_fn_set() - sampler = GridSampler(fn_space.input_domain, 15).make_static() - branch = FCBranchNet(fn_space, discretization_sampler=sampler) + branch = FCBranchNet(fn_space, grid=default_grid) + seq_trunk = Sequential(NormalizationLayer(Interval(R1('t'), 0, 1)), trunk) net = DeepONet(seq_trunk, branch, output_space=R1('u'), output_neurons=20) assert net.trunk == seq_trunk assert net.branch == branch @@ -126,10 +101,10 @@ def test_create_deeponet_with_seq_trunk(): def test_deeponet_fix_branch(): def f(t): return 20*t - trunk = TrunkNet(input_space=R1('t')) + default_grid = torch.rand((1, 100, 1)) + trunk = TrunkNet(input_space=R1('t'), default_trunk_input=default_grid) fn_space, _ = helper_fn_set() - sampler = GridSampler(fn_space.input_domain, 15).make_static() - branch = FCBranchNet(fn_space, discretization_sampler=sampler) + branch = FCBranchNet(fn_space, grid=default_grid) net = DeepONet(trunk, branch, output_space=R1('u'), output_neurons=20) net.fix_branch_input(f) assert branch.current_out.shape == (1, 1, 20) @@ -138,11 +113,10 @@ def f(t): def test_deeponet_forward(): def f(t): return 20*t - trunk = FCTrunkNet(input_space=R1('t'), xavier_gains=(1, 1, 1), - trunk_input_copied=False) + default_grid = torch.rand((1, 100, 1)) + trunk = FCTrunkNet(input_space=R1('t'), default_trunk_input=default_grid) fn_space, _ = helper_fn_set() - sampler = GridSampler(fn_space.input_domain, 15).make_static() - branch = FCBranchNet(fn_space, discretization_sampler=sampler, xavier_gains=(1, 1, 1)) + branch = FCBranchNet(fn_space, grid=default_grid) 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) @@ -153,11 +127,10 @@ def f(t): 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,)) + default_grid = torch.rand((1, 100, 1)) + trunk = FCTrunkNet(input_space=R1('t'), default_trunk_input=default_grid) 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,)) + branch = FCBranchNet(fn_space, grid=default_grid) 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) @@ -168,11 +141,11 @@ def f(t): def test_deeponet_forward_with_fixed_branch(): def f(t): return torch.sin(t) - trunk = FCTrunkNet(input_space=R1('t')) + default_grid = torch.rand((1, 100, 1)) + trunk = FCTrunkNet(input_space=R1('t'), default_trunk_input=default_grid) fn_space, _ = helper_fn_set() - sampler = GridSampler(fn_space.input_domain, 15).make_static() - branch = FCBranchNet(fn_space, discretization_sampler=sampler) - net = DeepONet(trunk, branch, output_space=R1('u'), output_neurons=12) + branch = FCBranchNet(fn_space, grid=default_grid) + net = DeepONet(trunk, branch, output_space=R1('u'), output_neurons=20) test_data = Points(torch.tensor([[[2], [0], [3.4], [2.9], [5.2]]]), R1('t')) net.fix_branch_input(f) out = net(test_data) @@ -181,13 +154,12 @@ def f(t): def test_deeponet_forward_branch_intern(): - trunk = FCTrunkNet(input_space=R1('t')) + default_grid = torch.rand((1, 100, 1)) + trunk = FCTrunkNet(input_space=R1('t'), default_trunk_input=default_grid) fn_space, fn_set = helper_fn_set() - sampler = GridSampler(fn_space.input_domain, 15).make_static() - branch = FCBranchNet(fn_space, discretization_sampler=sampler) + branch = FCBranchNet(fn_space, grid=default_grid) 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(): diff --git a/tests/tests_models/test_fno.py b/tests/tests_models/test_fno.py index 0a0e22b0..2fbed8c7 100644 --- a/tests/tests_models/test_fno.py +++ b/tests/tests_models/test_fno.py @@ -26,8 +26,6 @@ def test_create_fourier_layer_with_linear_transform(): def test_create_fourier_layer_with_batchnorm(): fourier_layer = _FourierLayer(8, 4, space_res=10) assert fourier_layer.use_bn - with pytest.raises(NotImplementedError): - fourier_layer = _FourierLayer(8, (4, 4), space_res=10) def test_forward_fourier_layer(): diff --git a/tests/tests_models/test_pcann.py b/tests/tests_models/test_pcann.py new file mode 100644 index 00000000..333ef843 --- /dev/null +++ b/tests/tests_models/test_pcann.py @@ -0,0 +1,79 @@ +import torch +import pytest + +from torchphysics.models.PCANN import PCANN_FC, PCANN +from torchphysics.problem.spaces import R1, R2, FunctionSpace +from torchphysics.problem.domains.functionsets.data_functionset import DataFunctionSet + +def test_pcann_create(): + T = R2("t") + U = R1("u") + model = PCANN_FC(T, U, + (torch.rand(100, 4), torch.rand(4), torch.rand(20, 4)), + (torch.rand(100, 6), torch.rand(6), torch.rand(30, 6)), + output_shape=[30] + ) + assert torch.is_tensor(model.mean_in) + assert torch.is_tensor(model.mean_out) + assert torch.is_tensor(model.std_in) + assert torch.is_tensor(model.std_out) + assert torch.is_tensor(model.eigenvalues_out) + assert torch.is_tensor(model.eigenvalues_in) + assert torch.is_tensor(model.eigenvectors_out) + assert torch.is_tensor(model.eigenvectors_in) + assert len(model.eigenvalues_in) == 4 + assert len(model.eigenvalues_out) == 6 + + +def test_pcann_create_from_fn_set(): + T = R2("t") + U = R1("u") + data = torch.rand((500, 100, 2)) + space = FunctionSpace(U, T) + data_fn_set = DataFunctionSet(space, data) + data_fn_set.compute_pca(12) + model = PCANN_FC.from_fn_set( + data_fn_set, data_fn_set + ) + assert torch.is_tensor(model.mean_in) + assert torch.is_tensor(model.mean_out) + assert torch.is_tensor(model.std_in) + assert torch.is_tensor(model.std_out) + assert torch.is_tensor(model.eigenvalues_out) + assert torch.is_tensor(model.eigenvalues_in) + assert torch.is_tensor(model.eigenvectors_out) + assert torch.is_tensor(model.eigenvectors_in) + assert len(model.eigenvalues_in) == 12 + assert len(model.eigenvalues_out) == 12 + + +def test_pcann_apply_network_gives_error(): + T = R2("t") + U = R1("u") + model = PCANN(T, U, + (torch.rand(100, 4), torch.rand(4), torch.rand(20, 4)), + (torch.rand(100, 6), torch.rand(6), torch.rand(30, 6)), + output_shape=[30] + ) + with pytest.raises(NotImplementedError): + _ = model.apply_network(None) + + +def test_pcann_forward(): + T = R2("t") + U = R1("u") + space = FunctionSpace(U, T) + data = torch.rand((500, 100, 2)) + data_out = torch.rand((500, 50, 50, 2)) + data_fn_set = DataFunctionSet(space, data) + data_fn_set_out = DataFunctionSet(space, data_out) + data_fn_set.compute_pca(12) + data_fn_set_out.compute_pca(20) + model = PCANN_FC.from_fn_set(data_fn_set, data_fn_set_out) + + input_data = torch.rand((30, 100, 2)) + output_data = model(input_data).as_tensor + assert torch.is_tensor(output_data) + assert output_data.shape[0] == 30 + assert output_data.shape[1] == 50 and output_data.shape[2] == 50 + assert output_data.shape[3] == 2 \ No newline at end of file diff --git a/tests/tests_sampler/test_function_sampler.py b/tests/tests_sampler/test_function_sampler.py new file mode 100644 index 00000000..2d294261 --- /dev/null +++ b/tests/tests_sampler/test_function_sampler.py @@ -0,0 +1,114 @@ +import torch +import pytest + +from torchphysics.problem.spaces import R1, FunctionSpace +from torchphysics.problem.domains.functionsets import CustomFunctionSet +from torchphysics.problem.samplers import GridSampler +from torchphysics.problem.domains.domain1D import Interval +from torchphysics.problem.samplers.function_sampler import ( + FunctionSampler, FunctionSamplerRandomUniform, FunctionSamplerOrdered, FunctionSamplerCoupled +) + + +def make_default_fn_set(): + sampler = GridSampler(Interval(R1("k"), 0, 1), 100) + custom_fn = lambda k : k+2 + space = FunctionSpace(R1("x"), R1("u")) + return CustomFunctionSet(space, sampler, custom_fn) + + +def test_create_function_sampler(): + fn_set = make_default_fn_set() + fn_sampler = FunctionSampler(20, fn_set, 100) + assert len(fn_sampler.current_indices) == 20 + assert fn_sampler.function_creation_interval == 100 + assert fn_sampler.n_functions == 20 + assert fn_sampler.iteration_counter == 100 + + +def test_function_sampler_recreation_check(): + fn_set = make_default_fn_set() + fn_sampler = FunctionSampler(20, fn_set, 100) + fn_sampler._check_recreate_functions() + assert fn_sampler.iteration_counter == 0 + + +def test_function_sampler_recreation_check_two_times(): + fn_set = make_default_fn_set() + fn_sampler = FunctionSampler(20, fn_set, 100) + fn_sampler._check_recreate_functions() + fn_sampler._check_recreate_functions() + assert fn_sampler.iteration_counter == 1 + + +def test_create_random_uniform_function_sampler(): + fn_set = make_default_fn_set() + fn_sampler = FunctionSamplerRandomUniform(20, fn_set, 100) + assert len(fn_sampler.current_indices) == 20 + assert fn_sampler.function_creation_interval == 100 + assert fn_sampler.n_functions == 20 + assert fn_sampler.iteration_counter == 100 + + +def test_random_uniform_function_sampler_sample(): + fn_set = make_default_fn_set() + fn_sampler = FunctionSamplerRandomUniform(20, fn_set, 100) + fns = fn_sampler.sample_functions() + assert torch.all(fn_sampler.current_indices < 100) + assert callable(fns) + + +def test_create_ordered_function_sampler(): + fn_set = make_default_fn_set() + fn_sampler = FunctionSamplerOrdered(20, fn_set, 100) + assert len(fn_sampler.current_indices) == 20 + assert fn_sampler.function_creation_interval == 100 + assert fn_sampler.n_functions == 20 + assert fn_sampler.iteration_counter == 100 + + +def test_ordered_function_sampler_sample(): + fn_set = make_default_fn_set() + fn_sampler = FunctionSamplerOrdered(20, fn_set, 100) + fns = fn_sampler.sample_functions() + assert torch.all(fn_sampler.current_indices >= 20) + assert torch.all(fn_sampler.current_indices < 40) + assert callable(fns) + + +def test_ordered_function_sampler_sample_two_times(): + fn_set = make_default_fn_set() + fn_sampler = FunctionSamplerOrdered(20, fn_set, 100) + fns = fn_sampler.sample_functions() + fns = fn_sampler.sample_functions() + assert torch.all(fn_sampler.current_indices >= 40) + assert torch.all(fn_sampler.current_indices < 60) + assert callable(fns) + + +def test_ordered_function_sampler_sample_multiple_times(): + fn_set = make_default_fn_set() + fn_sampler = FunctionSamplerOrdered(20, fn_set, 100) + for _ in range(5): + _ = fn_sampler.sample_functions() + assert torch.all(fn_sampler.current_indices >= 0) + assert torch.all(fn_sampler.current_indices < 20) + + +def test_create_coupled_function_sampler(): + fn_set = make_default_fn_set() + fn_sampler = FunctionSamplerOrdered(20, fn_set, 100) + fn_sampler2 = FunctionSamplerCoupled(fn_set, fn_sampler) + assert fn_sampler2.function_creation_interval == 100 + assert fn_sampler2.n_functions == 20 + assert fn_sampler2.iteration_counter == 100 + + +def test_coupled_function_sampler_sample(): + fn_set = make_default_fn_set() + fn_sampler = FunctionSamplerOrdered(20, fn_set, 100) + fn_sampler2 = FunctionSamplerCoupled(fn_set, fn_sampler) + _ = fn_sampler.sample_functions() + _ = fn_sampler2.sample_functions() + assert torch.all(fn_sampler2.current_indices >= 20) + assert torch.all(fn_sampler2.current_indices < 40) \ No newline at end of file diff --git a/tests/test_samplers.py b/tests/tests_sampler/test_samplers.py similarity index 100% rename from tests/test_samplers.py rename to tests/tests_sampler/test_samplers.py diff --git a/tests/tests_utils/test_differenceoperators.py b/tests/tests_utils/test_differenceoperators.py new file mode 100644 index 00000000..c8d4f7ac --- /dev/null +++ b/tests/tests_utils/test_differenceoperators.py @@ -0,0 +1,201 @@ +import pytest +import torch +import numpy as np +from torchphysics.utils.differentialoperators.differenceoperators import \ + (discrete_grad_on_grid, discrete_laplacian_on_grid) + + +def test_discrete_grad_in_1d(): + A = torch.ones(5, 10,1) + A_grad = discrete_grad_on_grid(A, 1) + assert A_grad.shape == (5, 10, 1) + + +def test_discrete_grad_in_2d(): + A = torch.ones(5,10,10,1) + A_grad = discrete_grad_on_grid(A, 1) + assert A_grad.shape == (5, 10, 10, 2) + + +def test_discrete_grad_in_3d(): + A = torch.ones(5,10,10,10,1) + A_grad = discrete_grad_on_grid(A, 1) + assert A_grad.shape == (5, 10, 10, 10, 3) + + +def test_discrete_grad_in_1d_multiple_outputs(): + A = torch.ones(5, 10, 2) + A_grad = discrete_grad_on_grid(A, 1) + assert A_grad.shape == (5, 10, 2) + + +def test_discrete_grad_in_2d_multiple_outputs(): + A = torch.ones(5,10,10,3) + A_grad = discrete_grad_on_grid(A, 1) + assert A_grad.shape == (5, 10, 10, 6) + + +def test_discrete_grad_in_3d_multiple_outputs(): + A = torch.ones(5,10,10,10,4) + A_grad = discrete_grad_on_grid(A, 1) + assert A_grad.shape == (5, 10, 10, 10, 12) + + +def test_discrete_grad_for_constant(): + A = torch.ones(5, 10, 10, 1) + A_grad = discrete_grad_on_grid(A, 1) + assert torch.allclose(A_grad, torch.zeros(5, 10, 10, 1)) + + +def test_discrete_grad_for_linear_fn(): + A = torch.linspace(0, 1, 10).reshape(1, 10, 1).repeat(10, 1, 1) + A_grad = discrete_grad_on_grid(A, 1.0/9.0) + assert torch.allclose(A_grad, torch.ones(10, 10, 1)) + + +def test_discrete_grad_for_linear_fn_scaled(): + A = torch.linspace(0, 1, 10).reshape(1, 10, 1).repeat(10, 1, 1) + A *= 3.0 + A += 2.0 + A_grad = discrete_grad_on_grid(A, 1.0/9.0) + assert torch.allclose(A_grad, 3.0*torch.ones(10, 10, 1)) + + +def test_discrete_grad_for_non_linear_fn(): + X = torch.linspace(0, 1, 10).reshape(1, 10, 1).repeat(10, 1, 1) + A = X**2 + A_grad = discrete_grad_on_grid(A, 1.0/9.0) + assert torch.allclose(A_grad, 2*X, atol=0.001) + + +def test_discrete_grad_for_linear_fn_2d(): + A = torch.linspace(0, 1, 20) + A = torch.transpose(torch.stack(torch.meshgrid((A, A))), 0, -1) + A = A[..., :1] + A[..., 1:] + A = A.reshape(1, 20, 20, 1).repeat(4, 1, 1, 1) + A_grad = discrete_grad_on_grid(A, 1.0/19.0) + assert torch.allclose(A_grad, torch.ones(4, 20, 20, 2)) + + +def test_discrete_grad_for_linear_fn_2d_scaled(): + A = torch.linspace(0, 1, 20) + A = torch.transpose(torch.stack(torch.meshgrid((A, A))), 0, -1) + A = torch.transpose(A, 0, 1) + + A = 2.0*A[..., :1] + 0.1*A[..., 1:] + A = A.reshape(1, 20, 20, 1).repeat(4, 1, 1, 1) + A_grad = discrete_grad_on_grid(A, 1.0/19.0) + assert torch.allclose(A_grad[..., :1], 2.0*torch.ones(4, 20, 20, 1), atol=0.0001) + assert torch.allclose(A_grad[..., 1:], 0.1*torch.ones(4, 20, 20, 1), atol=0.0001) + + +def test_discrete_grad_for_non_linear_fn_2d(): + X = torch.linspace(0, 1, 20) + X = torch.transpose(torch.stack(torch.meshgrid((X, X))), 0, -1) + X = torch.transpose(X, 0, 1) + + A = X[..., :1] * X[..., 1:]**2 + torch.sin(X[..., :1]) + A = A.reshape(1, 20, 20, 1).repeat(4, 1, 1, 1) + A_grad = discrete_grad_on_grid(A, 1.0/19.0) + real_grad_1 = X[..., 1:]**2 + torch.cos(X[..., :1]) + real_grad_2 = 2*X[..., :1]*X[..., 1:] + assert torch.allclose(A_grad[..., :1], real_grad_1, atol=0.001) + assert torch.allclose(A_grad[..., 1:], real_grad_2, atol=0.001) + + +def test_discrete_grad_for_non_rectangle(): + X = torch.linspace(0, 1, 50) + Y = torch.linspace(0, 2, 100) + X = torch.transpose(torch.stack(torch.meshgrid((X, Y))), 0, -1) + X = torch.transpose(X, 0, 1) + + A = X[..., :1] * X[..., 1:]**2 + torch.sin(X[..., :1]) + A = A.reshape(1, 50, 100, 1).repeat(4, 1, 1, 1) + A_grad = discrete_grad_on_grid(A, 1.0/49.0) + + real_grad_1 = X[..., 1:]**2 + torch.cos(X[..., :1]) + real_grad_2 = 2*X[..., :1]*X[..., 1:] + assert torch.allclose(A_grad[..., :1], real_grad_1, atol=0.05) + assert torch.allclose(A_grad[..., 1:], real_grad_2, atol=0.05) + +###################################################################################### +def test_discrete_laplace_in_1d(): + A = torch.ones(5, 10,1) + A_lap = discrete_laplacian_on_grid(A, 1) + assert A_lap.shape == (5, 10, 1) + + +def test_discrete_laplace_in_2d(): + A = torch.ones(5,10,10,1) + A_lap = discrete_laplacian_on_grid(A, 1) + assert A_lap.shape == (5, 10, 10, 1) + + +def test_discrete_laplace_in_3d(): + A = torch.ones(5,10,10,10,1) + A_lap = discrete_laplacian_on_grid(A, 1) + assert A_lap.shape == (5, 10, 10, 10, 1) + + +def test_discrete_laplace_in_1d_multiple_outputs(): + A = torch.ones(5, 10, 2) + A_lap = discrete_laplacian_on_grid(A, 1) + assert A_lap.shape == (5, 10, 2) + + +def test_discrete_laplace_in_2d_multiple_outputs(): + A = torch.ones(5,10,10,3) + A_lap = discrete_laplacian_on_grid(A, 1) + assert A_lap.shape == (5, 10, 10, 3) + + +def test_discrete_laplace_for_constant_fn(): + A = torch.ones(5, 10, 10, 1) + A_lap = discrete_laplacian_on_grid(A, 1) + assert torch.allclose(A_lap, torch.zeros(5, 10, 10, 1)) + + +def test_discrete_grad_for_quadratic_fn(): + X = torch.linspace(0, 1, 10).reshape(1, 10, 1).repeat(10, 1, 1) + A = X**2 + A_lap = discrete_laplacian_on_grid(A, 1.0/9.0) + assert torch.allclose(A_lap, 2.0*torch.ones_like(X), atol=0.001) + + +def test_discrete_grad_for_general_fn(): + X = torch.linspace(0, 1, 10).reshape(1, 10, 1).repeat(10, 1, 1) + A = torch.sin(X) + 5.0*X**2 - 1.0 + A_lap = discrete_laplacian_on_grid(A, 1.0/9.0) + real_lap = -torch.sin(X) + 10.0 + assert torch.allclose(A_lap, real_lap, atol=0.01) + + +def test_discrete_laplace_for_constant_fn_2d(): + A = 3.0*torch.ones(5, 10, 10, 1) + A_lap = discrete_laplacian_on_grid(A, 1) + assert torch.allclose(A_lap, torch.zeros(5, 10, 10, 1)) + + +def test_discrete_laplace_for_quadratic_fn_2d(): + X = torch.linspace(0, 1, 20) + X = torch.transpose(torch.stack(torch.meshgrid((X, X))), 0, -1) + X = torch.transpose(X, 0, 1) + + A = X[..., :1]**2 + X[..., 1:]**2 + A = A.reshape(1, 20, 20, 1).repeat(4, 1, 1, 1) + + A_lap = discrete_laplacian_on_grid(A, 1/19.0) + assert torch.allclose(A_lap, 4.0*torch.ones(4, 20, 20, 1), atol=0.001) + + +def test_discrete_laplace_for_general_fn_2d(): + X = torch.linspace(0, 1, 20) + X = torch.transpose(torch.stack(torch.meshgrid((X, X))), 0, -1) + X = torch.transpose(X, 0, 1) + + A = torch.sin(X[..., :1]) + X[..., 1:]**2 + X[..., :1]**2 * X[..., 1:] + A = A.reshape(1, 20, 20, 1).repeat(4, 1, 1, 1) + + A_lap = discrete_laplacian_on_grid(A, 1/19.0) + real_lap = -torch.sin(X[..., :1]) + 2.0 + 2.0 * X[..., 1:] + assert torch.allclose(A_lap, real_lap, atol=0.01) \ No newline at end of file diff --git a/tests/tests_utils/test_differentialoperators.py b/tests/tests_utils/test_differentialoperators.py index 02ca5258..677a7d23 100644 --- a/tests/tests_utils/test_differentialoperators.py +++ b/tests/tests_utils/test_differentialoperators.py @@ -1,7 +1,7 @@ import pytest import torch import numpy as np -from torchphysics.utils.differentialoperators import (laplacian, +from torchphysics.utils.differentialoperators.differentialoperators import (laplacian, grad, normal_derivative, div,