From 96899dac50205b5181f24396182c66d356ae4644 Mon Sep 17 00:00:00 2001 From: Dario Coscia Date: Thu, 13 Mar 2025 18:20:18 +0100 Subject: [PATCH] Update Tutorials 0.2 --- .gitignore | 6 + pina/problem/zoo/supervised_problem.py | 16 +- pina/trainer.py | 3 - pyproject.toml | 9 +- tutorials/README.md | 1 + tutorials/tutorial1/tutorial.ipynb | 266 +++++----- tutorials/tutorial1/tutorial.py | 322 ------------ tutorials/tutorial10/tutorial.ipynb | 78 ++- tutorials/tutorial10/tutorial.py | 274 ----------- tutorials/tutorial11/tutorial.ipynb | 217 ++++---- tutorials/tutorial11/tutorial.py | 356 -------------- tutorials/tutorial12/tutorial.ipynb | 98 ++-- tutorials/tutorial12/tutorial.py | 156 ------ tutorials/tutorial13/tutorial.ipynb | 204 ++++---- tutorials/tutorial13/tutorial.py | 241 --------- tutorials/tutorial2/tutorial.ipynb | 306 +++++++----- tutorials/tutorial2/tutorial.py | 331 ------------- tutorials/tutorial3/tutorial.ipynb | 174 +++---- tutorials/tutorial3/tutorial.py | 355 -------------- tutorials/tutorial4/tutorial.ipynb | 568 ++++++++++----------- tutorials/tutorial4/tutorial.py | 653 ------------------------- tutorials/tutorial5/tutorial.ipynb | 145 +++--- tutorials/tutorial5/tutorial.py | 189 ------- tutorials/tutorial6/tutorial.ipynb | 157 +++--- tutorials/tutorial6/tutorial.py | 274 ----------- tutorials/tutorial7/tutorial.ipynb | 224 +++++---- tutorials/tutorial7/tutorial.py | 220 --------- tutorials/tutorial8/tutorial.ipynb | 226 ++++----- tutorials/tutorial8/tutorial.py | 309 ------------ tutorials/tutorial9/tutorial.ipynb | 147 +++--- tutorials/tutorial9/tutorial.py | 235 --------- 31 files changed, 1528 insertions(+), 5232 deletions(-) delete mode 100644 tutorials/tutorial1/tutorial.py delete mode 100644 tutorials/tutorial10/tutorial.py delete mode 100644 tutorials/tutorial11/tutorial.py delete mode 100644 tutorials/tutorial12/tutorial.py delete mode 100644 tutorials/tutorial13/tutorial.py delete mode 100644 tutorials/tutorial2/tutorial.py delete mode 100644 tutorials/tutorial3/tutorial.py delete mode 100644 tutorials/tutorial4/tutorial.py delete mode 100644 tutorials/tutorial5/tutorial.py delete mode 100644 tutorials/tutorial6/tutorial.py delete mode 100644 tutorials/tutorial7/tutorial.py delete mode 100644 tutorials/tutorial8/tutorial.py delete mode 100644 tutorials/tutorial9/tutorial.py diff --git a/.gitignore b/.gitignore index b84bbdeee..11be017f7 100644 --- a/.gitignore +++ b/.gitignore @@ -139,3 +139,9 @@ cython_debug/ # Lightning logs dir **lightning_logs + +# Tutorial logs dir +**tutorial_logs + +# tmp dir +**tmp* diff --git a/pina/problem/zoo/supervised_problem.py b/pina/problem/zoo/supervised_problem.py index 7e39a502a..45c75a1c6 100644 --- a/pina/problem/zoo/supervised_problem.py +++ b/pina/problem/zoo/supervised_problem.py @@ -2,7 +2,7 @@ from ..abstract_problem import AbstractProblem from ... import Condition -from ... import Graph +from ... import LabelTensor class SupervisedProblem(AbstractProblem): @@ -22,16 +22,22 @@ class SupervisedProblem(AbstractProblem): conditions = {} output_variables = None + input_variables = None - def __init__(self, input_, output_): + def __init__( + self, input_, output_, input_variables=None, output_variables=None + ): """ Initialize the SupervisedProblem class. :param input_: Input data of the problem. + :type input_: torch.Tensor | LabelTensor | Graph | Data :param output_: Output data of the problem. - :type output_: torch.Tensor | Graph + :type output_: torch.Tensor | LabelTensor | Graph | Data """ - if isinstance(input_, Graph): - input_ = input_.data + # Set input and output variables + self.input_variables = input_variables + self.output_variables = output_variables + # Set the condition self.conditions["data"] = Condition(input=input_, target=output_) super().__init__() diff --git a/pina/trainer.py b/pina/trainer.py index 81abfbd17..c2dbe1c9b 100644 --- a/pina/trainer.py +++ b/pina/trainer.py @@ -127,9 +127,6 @@ def __init__( # logging self.logging_kwargs = { - "logger": bool( - kwargs["logger"] is not None or kwargs["logger"] is True - ), "sync_dist": bool( len(self._accelerator_connector._parallel_devices) > 1 ), diff --git a/pyproject.toml b/pyproject.toml index 5ea7fc58c..457f76942 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -22,7 +22,7 @@ dependencies = [ requires-python = ">=3.8" [project.optional-dependencies] -docs = [ +doc = [ "sphinx>5.0", "sphinx_rtd_theme", "sphinx_copybutton", @@ -37,8 +37,13 @@ test = [ dev = [ "black @ git+https://github.com/psf/black" ] -tutorials = [ +tutorial = [ + "jupyter", "smithers @ git+https://github.com/mathLab/smithers.git", + "torchvision", + "tensorboard", + "scipy", + "numpy", ] [project.urls] diff --git a/tutorials/README.md b/tutorials/README.md index 5838a1fff..3129dd9b7 100644 --- a/tutorials/README.md +++ b/tutorials/README.md @@ -33,3 +33,4 @@ Time dependent Kuramoto Sivashinsky equation using the Averaging Neural Operator |---------------|-----------| Unstructured convolutional autoencoder via continuous convolution |[[.ipynb](tutorial4/tutorial.ipynb), [.py](tutorial4/tutorial.py), [.html](http://mathlab.github.io/PINA/_rst/tutorials/tutorial4/tutorial.html)]| POD-RBF and POD-NN for reduced order modeling| [[.ipynb](tutorial8/tutorial.ipynb), [.py](tutorial8/tutorial.py), [.html](http://mathlab.github.io/PINA/_rst/tutorials/tutorial8/tutorial.html)]| +POD-RBF for modelling Lid Cavity| [[.ipynb](tutorial14/tutorial.ipynb), [.py](tutorial14/tutorial.py), [.html](http://mathlab.github.io/PINA/_rst/tutorials/tutorial14/tutorial.html)]| diff --git a/tutorials/tutorial1/tutorial.ipynb b/tutorials/tutorial1/tutorial.ipynb index 1afb6da0a..4a0d205c2 100644 --- a/tutorials/tutorial1/tutorial.ipynb +++ b/tutorials/tutorial1/tutorial.ipynb @@ -138,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "f2608e2e", "metadata": {}, "outputs": [], @@ -152,38 +152,39 @@ "from pina.domain import CartesianDomain\n", "from pina.equation import Equation, FixedValue\n", "\n", - "class SimpleODE(SpatialProblem):\n", + "# defining the ode equation\n", + "def ode_equation(input_, output_):\n", "\n", - " output_variables = ['u']\n", - " spatial_domain = CartesianDomain({'x': [0, 1]})\n", + " # computing the derivative\n", + " u_x = grad(output_, input_, components=[\"u\"], d=[\"x\"])\n", "\n", - " domains ={\n", - " 'x0': CartesianDomain({'x': 0.}),\n", - " 'D': CartesianDomain({'x': [0, 1]})\n", - " }\n", + " # extracting the u input variable\n", + " u = output_.extract([\"u\"])\n", "\n", - " # defining the ode equation\n", - " def ode_equation(input_, output_):\n", + " # calculate the residual and return it\n", + " return u_x - u\n", "\n", - " # computing the derivative\n", - " u_x = grad(output_, input_, components=['u'], d=['x'])\n", + "class SimpleODE(SpatialProblem):\n", "\n", - " # extracting the u input variable\n", - " u = output_.extract(['u'])\n", + " output_variables = [\"u\"]\n", + " spatial_domain = CartesianDomain({\"x\": [0, 1]})\n", "\n", - " # calculate the residual and return it\n", - " return u_x - u\n", + " domains = {\n", + " \"x0\": CartesianDomain({\"x\": 0.0}),\n", + " \"D\": CartesianDomain({\"x\": [0, 1]}),\n", + " }\n", "\n", " # conditions to hold\n", " conditions = {\n", - " 'bound_cond': Condition(domain='x0', equation=FixedValue(1.)),\n", - " 'phys_cond': Condition(domain='D', equation=Equation(ode_equation))\n", + " \"bound_cond\": Condition(domain=\"x0\", equation=FixedValue(1.0)),\n", + " \"phys_cond\": Condition(domain=\"D\", equation=Equation(ode_equation)),\n", " }\n", "\n", " # defining the true solution\n", - " def truth_solution(self, pts):\n", - " return torch.exp(pts.extract(['x']))\n", - " \n", + " def solution(self, pts):\n", + " return torch.exp(pts.extract([\"x\"]))\n", + "\n", + "\n", "problem = SimpleODE()" ] }, @@ -197,7 +198,7 @@ "\n", "Once we have defined the function, we need to tell the neural network where these methods are to be applied. To do so, we use the `Condition` class. In the `Condition` class, we pass the location points and the equation we want minimized on those points (other possibilities are allowed, see the documentation for reference).\n", "\n", - "Finally, it's possible to define a `truth_solution` function, which can be useful if we want to plot the results and see how the real solution compares to the expected (true) solution. Notice that the `truth_solution` function is a method of the `PINN` class, but it is not mandatory for problem definition.\n" + "Finally, it's possible to define a `solution` function, which can be useful if we want to plot the results and see how the real solution compares to the expected (true) solution. Notice that the `solution` function is a method of the `PINN` class, but it is not mandatory for problem definition.\n" ] }, { @@ -213,20 +214,20 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "09ce5c3a", "metadata": {}, "outputs": [], "source": [ "# sampling 20 points in [0, 1] through discretization in all locations\n", - "problem.discretise_domain(n=20, mode='grid', domains='all')\n", + "problem.discretise_domain(n=20, mode=\"grid\", domains=\"all\")\n", "\n", "# sampling 20 points in (0, 1) through latin hypercube sampling in D, and 1 point in x0\n", - "problem.discretise_domain(n=20, mode='latin', domains=['D'])\n", - "problem.discretise_domain(n=1, mode='random', domains=['x0'])\n", + "problem.discretise_domain(n=20, mode=\"latin\", domains=[\"D\"])\n", + "problem.discretise_domain(n=1, mode=\"random\", domains=[\"x0\"])\n", "\n", "# sampling 20 points in (0, 1) randomly\n", - "problem.discretise_domain(n=20, mode='random')" + "problem.discretise_domain(n=20, mode=\"random\")" ] }, { @@ -239,14 +240,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "329962b6", "metadata": {}, "outputs": [], "source": [ "# sampling for training\n", - "problem.discretise_domain(1, 'random', domains=['x0']) # TODO check\n", - "problem.discretise_domain(20, 'lh', domains=['D'])" + "problem.discretise_domain(1, \"random\", domains=[\"x0\"])\n", + "problem.discretise_domain(20, \"lh\", domains=[\"D\"])" ] }, { @@ -259,7 +260,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "d6ed9aaf", "metadata": {}, "outputs": [ @@ -267,33 +268,33 @@ "name": "stdout", "output_type": "stream", "text": [ - "Input points: {'x0': LabelTensor([[0.]]), 'D': LabelTensor([[0.6732],\n", - " [0.9077],\n", - " [0.7904],\n", - " [0.1018],\n", - " [0.4341],\n", - " [0.3175],\n", - " [0.7237],\n", - " [0.8685],\n", - " [0.0957],\n", - " [0.1807],\n", - " [0.2316],\n", - " [0.0491],\n", - " [0.9556],\n", - " [0.2708],\n", - " [0.4589],\n", - " [0.5172],\n", - " [0.3763],\n", - " [0.8106],\n", - " [0.6397],\n", - " [0.5970]])}\n", + "Input points: {'x0': LabelTensor([[0.]]), 'D': LabelTensor([[0.3097],\n", + " [0.9524],\n", + " [0.6227],\n", + " [0.9200],\n", + " [0.1549],\n", + " [0.8729],\n", + " [0.8064],\n", + " [0.3929],\n", + " [0.1100],\n", + " [0.4493],\n", + " [0.2909],\n", + " [0.6947],\n", + " [0.0141],\n", + " [0.4516],\n", + " [0.5632],\n", + " [0.5328],\n", + " [0.7851],\n", + " [0.0829],\n", + " [0.7144],\n", + " [0.2229]])}\n", "Input points labels: ['x']\n" ] } ], "source": [ - "print('Input points:', problem.discretised_domains)\n", - "print('Input points labels:', problem.discretised_domains['D'].labels)" + "print(\"Input points:\", problem.discretised_domains)\n", + "print(\"Input points labels:\", problem.discretised_domains[\"D\"].labels)" ] }, { @@ -306,13 +307,23 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "3802e22a", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -322,13 +333,12 @@ } ], "source": [ - "variables=problem.spatial_variables\n", - "fig = plt.figure()\n", - "proj = \"3d\" if len(variables) == 3 else None\n", - "ax = fig.add_subplot(projection=proj)\n", "for location in problem.input_pts:\n", - " coords = problem.input_pts[location].extract(variables).T.detach()\n", - " ax.plot(coords.flatten(),torch.zeros(coords.flatten().shape),\".\",label=location)\n" + " coords = (\n", + " problem.input_pts[location].extract(problem.spatial_variables).flatten()\n", + " )\n", + " plt.scatter(coords, torch.zeros_like(coords), s=10, label=location)\n", + "plt.legend()" ] }, { @@ -351,7 +361,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "3bb4dc9b", "metadata": {}, "outputs": [ @@ -359,7 +369,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "GPU available: False, used: False\n", + "GPU available: True (mps), used: False\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n" ] @@ -368,7 +378,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch 1499: 100%|██████████| 1/1 [00:00<00:00, 87.10it/s, v_num=0, bound_cond_loss=1.61e-9, phys_cond_loss=5.27e-6, train_loss=5.27e-6] " + "Epoch 1499: 100%|██████████| 1/1 [00:00<00:00, 149.92it/s, v_num=0, bound_cond_loss=1.52e-8, phys_cond_loss=7.68e-6, train_loss=7.69e-6] " ] }, { @@ -382,7 +392,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch 1499: 100%|██████████| 1/1 [00:00<00:00, 58.01it/s, v_num=0, bound_cond_loss=1.61e-9, phys_cond_loss=5.27e-6, train_loss=5.27e-6]\n" + "Epoch 1499: 100%|██████████| 1/1 [00:00<00:00, 100.10it/s, v_num=0, bound_cond_loss=1.52e-8, phys_cond_loss=7.68e-6, train_loss=7.69e-6]\n" ] } ], @@ -399,19 +409,23 @@ " layers=[10, 10],\n", " func=torch.nn.Tanh,\n", " output_dimensions=len(problem.output_variables),\n", - " input_dimensions=len(problem.input_variables)\n", + " input_dimensions=len(problem.input_variables),\n", ")\n", "\n", "# create the PINN object\n", "pinn = PINN(problem, model, TorchOptimizer(torch.optim.Adam, lr=0.005))\n", "\n", "# create the trainer\n", - "trainer = Trainer(solver=pinn, max_epochs=1500, logger=TensorBoardLogger('tutorial_logs'), \n", - " accelerator='cpu',\n", - " train_size=1.0,\n", - " test_size=0.0,\n", - " val_size=0.0,\n", - " enable_model_summary=False) # we train on CPU and avoid model summary at beginning of training (optional)\n", + "trainer = Trainer(\n", + " solver=pinn,\n", + " max_epochs=1500,\n", + " logger=TensorBoardLogger(\"tutorial_logs\"),\n", + " accelerator=\"cpu\",\n", + " train_size=1.0,\n", + " test_size=0.0,\n", + " val_size=0.0,\n", + " enable_model_summary=False,\n", + ") # we train on CPU and avoid model summary at beginning of training (optional)\n", "\n", "# train\n", "trainer.train()" @@ -427,19 +441,19 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 27, "id": "f5fbf362", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'bound_cond_loss': tensor(1.6091e-09),\n", - " 'phys_cond_loss': tensor(5.2722e-06),\n", - " 'train_loss': tensor(5.2738e-06)}" + "{'bound_cond_loss': tensor(1.5208e-08),\n", + " 'phys_cond_loss': tensor(7.6781e-06),\n", + " 'train_loss': tensor(7.6933e-06)}" ] }, - "execution_count": 8, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -459,23 +473,23 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "ffbf0d5e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 9, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -485,13 +499,12 @@ } ], "source": [ - "pts = pinn.problem.spatial_domain.sample(256, 'grid', variables='x')\n", - "predicted_output = pinn.forward(pts).extract('u').as_subclass(torch.Tensor).cpu().detach()\n", - "true_output = pinn.problem.truth_solution(pts).cpu().detach()\n", - "pts = pts.cpu()\n", + "pts = pinn.problem.spatial_domain.sample(256, \"grid\", variables=\"x\")\n", + "predicted_output = pinn.forward(pts).extract(\"u\").tensor.detach()\n", + "true_output = pinn.problem.solution(pts).detach()\n", "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8, 8))\n", - "ax.plot(pts.extract(['x']), predicted_output, label='Neural Network solution')\n", - "ax.plot(pts.extract(['x']), true_output, label='True solution')\n", + "ax.plot(pts.extract([\"x\"]), predicted_output, label=\"Neural Network solution\")\n", + "ax.plot(pts.extract([\"x\"]), true_output, label=\"True solution\")\n", "plt.legend()" ] }, @@ -509,10 +522,22 @@ "id": "fcac93e4", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "To load TensorBoard run load_ext tensorboard on your terminal\n", + "To visualize the loss you can run tensorboard --logdir 'tutorial_logs' on your terminal\n", + "\n", + "The tensorboard extension is already loaded. To reload it, use:\n", + " %reload_ext tensorboard\n" + ] + }, { "data": { "text/plain": [ - "Reusing TensorBoard on port 6006 (pid 39131), started 2:16:30 ago. (Use '!kill 39131' to kill it.)" + "Reusing TensorBoard on port 6007 (pid 55149), started 0:00:03 ago. (Use '!kill 55149' to kill it.)" ] }, "metadata": {}, @@ -522,13 +547,13 @@ "data": { "text/html": [ "\n", - " \n", "