From 88df3c075abb5dc52147220323138a5e64cbb485 Mon Sep 17 00:00:00 2001 From: GiovanniCanali Date: Tue, 29 Sep 2026 12:20:18 +0200 Subject: [PATCH] update tutorial references --- tutorials/README.md | 50 ++++++++++++++--------------- tutorials/TUTORIAL_GUIDELINES.md | 4 +-- tutorials/tutorial1/tutorial.ipynb | 16 ++++----- tutorials/tutorial10/tutorial.ipynb | 18 +++++------ tutorials/tutorial11/tutorial.ipynb | 10 +++--- tutorials/tutorial12/tutorial.ipynb | 6 ++-- tutorials/tutorial13/tutorial.ipynb | 10 +++--- tutorials/tutorial14/tutorial.ipynb | 10 +++--- tutorials/tutorial15/tutorial.ipynb | 10 +++--- tutorials/tutorial16/tutorial.ipynb | 24 +++++++------- tutorials/tutorial17/tutorial.ipynb | 24 +++++++------- tutorials/tutorial18/tutorial.ipynb | 28 ++++++++-------- tutorials/tutorial19/tutorial.ipynb | 8 ++--- tutorials/tutorial2/tutorial.ipynb | 6 ++-- tutorials/tutorial20/tutorial.ipynb | 10 +++--- tutorials/tutorial21/tutorial.ipynb | 22 ++++++------- tutorials/tutorial22/tutorial.ipynb | 12 +++---- tutorials/tutorial23/tutorial.ipynb | 8 ++--- tutorials/tutorial24/tutorial.ipynb | 16 ++++----- tutorials/tutorial3/tutorial.ipynb | 4 +-- tutorials/tutorial4/tutorial.ipynb | 4 +-- tutorials/tutorial5/tutorial.ipynb | 6 ++-- tutorials/tutorial6/tutorial.ipynb | 4 +-- tutorials/tutorial7/tutorial.ipynb | 10 +++--- tutorials/tutorial8/tutorial.ipynb | 4 +-- tutorials/tutorial9/tutorial.ipynb | 4 +-- 26 files changed, 164 insertions(+), 164 deletions(-) diff --git a/tutorials/README.md b/tutorials/README.md index 464b71121..160a87df7 100644 --- a/tutorials/README.md +++ b/tutorials/README.md @@ -2,49 +2,49 @@ In this folder we collect useful tutorials in order to understand the principles and the potential of **PINA**. Whether you're just getting started or looking to deepen your understanding, these resources are here to guide you. -The table below provides an overview of each tutorial. All tutorials are also available in HTML in the official [PINA documentation](http://mathlab.github.io/PINA/). +The table below provides an overview of each tutorial. All tutorials are also available in HTML in the official [PINA documentation](http://PINA-org.github.io/PINA/). ## Getting started with PINA | Description | Tutorial | |---------------|-----------| -Introductory Tutorial: A Beginner’s Guide to PINA|[[.ipynb](tutorial17/tutorial.ipynb),[.py](tutorial17/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial17/tutorial.html)]| -How to build a `Problem` in PINA|[[.ipynb](tutorial16/tutorial.ipynb),[.py](tutorial16/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial16/tutorial.html)]| -Introduction to Solver classes|[[.ipynb](tutorial18/tutorial.ipynb),[.py](tutorial18/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial18/tutorial.html)]| -Introduction to `Trainer` class|[[.ipynb](tutorial11/tutorial.ipynb),[.py](tutorial11/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial11/tutorial.html)]| -Data structure for SciML: `Tensor`, `LabelTensor`, `Data` and `Graph` |[[.ipynb](tutorial19/tutorial.ipynb),[.py](tutorial19/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial19/tutorial.html)]| -Building domains with PINA's BaseDomain class|[[.ipynb](tutorial6/tutorial.ipynb),[.py](tutorial6/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial6/tutorial.html)]| -Introduction to PINA `Equation` class|[[.ipynb](tutorial12/tutorial.ipynb),[.py](tutorial12/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial12/tutorial.html)]| +Introductory Tutorial: A Beginner’s Guide to PINA|[[.ipynb](tutorial17/tutorial.ipynb),[.py](tutorial17/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial17/tutorial.html)]| +How to build a `Problem` in PINA|[[.ipynb](tutorial16/tutorial.ipynb),[.py](tutorial16/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial16/tutorial.html)]| +Introduction to Solver classes|[[.ipynb](tutorial18/tutorial.ipynb),[.py](tutorial18/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial18/tutorial.html)]| +Introduction to `Trainer` class|[[.ipynb](tutorial11/tutorial.ipynb),[.py](tutorial11/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial11/tutorial.html)]| +Data structure for SciML: `Tensor`, `LabelTensor`, `Data` and `Graph` |[[.ipynb](tutorial19/tutorial.ipynb),[.py](tutorial19/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial19/tutorial.html)]| +Building domains with PINA's BaseDomain class|[[.ipynb](tutorial6/tutorial.ipynb),[.py](tutorial6/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial6/tutorial.html)]| +Introduction to PINA `Equation` class|[[.ipynb](tutorial12/tutorial.ipynb),[.py](tutorial12/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial12/tutorial.html)]| ## Physics Informed Neural Networks | Description | Tutorial | |---------------|-----------| -Introductory Tutorial: Physics Informed Neural Networks with PINA |[[.ipynb](tutorial1/tutorial.ipynb),[.py](tutorial1/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial1/tutorial.html)]| -Enhancing PINNs with Extra Features to solve the Poisson Problem |[[.ipynb](tutorial2/tutorial.ipynb),[.py](tutorial2/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial2/tutorial.html)]| -Applying Hard Constraints in PINNs to solve the Wave Problem |[[.ipynb](tutorial3/tutorial.ipynb),[.py](tutorial3/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial3/tutorial.html)]| -Applying Periodic Boundary Conditions in PINNs to solve the Helmholtz Problem |[[.ipynb](tutorial9/tutorial.ipynb),[.py](tutorial9/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial9/tutorial.html)]| -Inverse Problem Solving with Physics-Informed Neural Network |[[.ipynb](tutorial7/tutorial.ipynb),[.py](tutorial7/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial7/tutorial.html)]| -Learning Multiscale PDEs Using Fourier Feature Networks|[[.ipynb](tutorial13/tutorial.ipynb),[.py](tutorial13/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial13/tutorial.html)]| -Learning Bifurcating PDE Solutions with Physics-Informed Deep Ensembles|[[.ipynb](tutorial14/tutorial.ipynb),[.py](tutorial14/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial14/tutorial.html)]| +Introductory Tutorial: Physics Informed Neural Networks with PINA |[[.ipynb](tutorial1/tutorial.ipynb),[.py](tutorial1/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial1/tutorial.html)]| +Enhancing PINNs with Extra Features to solve the Poisson Problem |[[.ipynb](tutorial2/tutorial.ipynb),[.py](tutorial2/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial2/tutorial.html)]| +Applying Hard Constraints in PINNs to solve the Wave Problem |[[.ipynb](tutorial3/tutorial.ipynb),[.py](tutorial3/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial3/tutorial.html)]| +Applying Periodic Boundary Conditions in PINNs to solve the Helmholtz Problem |[[.ipynb](tutorial9/tutorial.ipynb),[.py](tutorial9/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial9/tutorial.html)]| +Inverse Problem Solving with Physics-Informed Neural Network |[[.ipynb](tutorial7/tutorial.ipynb),[.py](tutorial7/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial7/tutorial.html)]| +Learning Multiscale PDEs Using Fourier Feature Networks|[[.ipynb](tutorial13/tutorial.ipynb),[.py](tutorial13/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial13/tutorial.html)]| +Learning Bifurcating PDE Solutions with Physics-Informed Deep Ensembles|[[.ipynb](tutorial14/tutorial.ipynb),[.py](tutorial14/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial14/tutorial.html)]| ## Neural Operator Learning | Description | Tutorial | |---------------|-----------| -Introductory Tutorial: Neural Operator Learning with PINA |[[.ipynb](tutorial21/tutorial.ipynb),[.py](tutorial21/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial21/tutorial.html)]| -Modeling 2D Darcy Flow with the Fourier Neural Operator |[[.ipynb](tutorial5/tutorial.ipynb),[.py](tutorial5/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial5/tutorial.html)]| -Solving the Kuramoto–Sivashinsky Equation with Averaging Neural Operator |[[.ipynb](tutorial10/tutorial.ipynb),[.py](tutorial10/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial10/tutorial.html)]| -Advection Equation with data driven DeepONet| [[.ipynb](tutorial24/tutorial.ipynb),[.py](tutorial24/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial24/tutorial.html)]| +Introductory Tutorial: Neural Operator Learning with PINA |[[.ipynb](tutorial21/tutorial.ipynb),[.py](tutorial21/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial21/tutorial.html)]| +Modeling 2D Darcy Flow with the Fourier Neural Operator |[[.ipynb](tutorial5/tutorial.ipynb),[.py](tutorial5/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial5/tutorial.html)]| +Solving the Kuramoto–Sivashinsky Equation with Averaging Neural Operator |[[.ipynb](tutorial10/tutorial.ipynb),[.py](tutorial10/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial10/tutorial.html)]| +Advection Equation with data driven DeepONet| [[.ipynb](tutorial24/tutorial.ipynb),[.py](tutorial24/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial24/tutorial.html)]| ## Supervised Learning | Description | Tutorial | |---------------|-----------| -Introductory Tutorial: Supervised Learning with PINA |[[.ipynb](tutorial20/tutorial.ipynb),[.py](tutorial20/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial20/tutorial.html)]| -Chemical Properties Prediction with Graph Neural Networks |[[.ipynb](tutorial15/tutorial.ipynb),[.py](tutorial15/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial15/tutorial.html)]| -Reduced Order Model with Graph Neural Networks for Unstructured Domains| [[.ipynb](tutorial22/tutorial.ipynb),[.py](tutorial22/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial22/tutorial.html)]| -Data-driven System Identification with SINDy| [[.ipynb](tutorial23/tutorial.ipynb),[.py](tutorial23/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial23/tutorial.html)]| -Unstructured Convolutional Autoencoders with Continuous Convolution |[[.ipynb](tutorial4/tutorial.ipynb),[.py](tutorial4/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial4/tutorial.html)]| -Reduced Order Modeling with POD-RBF and POD-NN Approaches for Fluid Dynamics| [[.ipynb](tutorial8/tutorial.ipynb),[.py](tutorial8/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial8/tutorial.html)]| +Introductory Tutorial: Supervised Learning with PINA |[[.ipynb](tutorial20/tutorial.ipynb),[.py](tutorial20/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial20/tutorial.html)]| +Chemical Properties Prediction with Graph Neural Networks |[[.ipynb](tutorial15/tutorial.ipynb),[.py](tutorial15/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial15/tutorial.html)]| +Reduced Order Model with Graph Neural Networks for Unstructured Domains| [[.ipynb](tutorial22/tutorial.ipynb),[.py](tutorial22/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial22/tutorial.html)]| +Data-driven System Identification with SINDy| [[.ipynb](tutorial23/tutorial.ipynb),[.py](tutorial23/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial23/tutorial.html)]| +Unstructured Convolutional Autoencoders with Continuous Convolution |[[.ipynb](tutorial4/tutorial.ipynb),[.py](tutorial4/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial4/tutorial.html)]| +Reduced Order Modeling with POD-RBF and POD-NN Approaches for Fluid Dynamics| [[.ipynb](tutorial8/tutorial.ipynb),[.py](tutorial8/tutorial.py),[.html](http://PINA-org.github.io/PINA/tutorial8/tutorial.html)]| diff --git a/tutorials/TUTORIAL_GUIDELINES.md b/tutorials/TUTORIAL_GUIDELINES.md index 0475cb553..e3c20fe21 100644 --- a/tutorials/TUTORIAL_GUIDELINES.md +++ b/tutorials/TUTORIAL_GUIDELINES.md @@ -100,7 +100,7 @@ Congratulations on completing the ..., here are a few directions you can explore 3. **...and many more!** — Other suggestions .... -For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/). +For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/). ``` ## Writing Style @@ -116,7 +116,7 @@ For more resources and tutorials, check out the [PINA Documentation](https://mat Every tutorial should: - Be executable from top to bottom. -- Use the `tutorial` requirements in the [`pyproject.toml`](https://github.com/mathLab/PINA/blob/6ed3ca04fee3ae3673d53ea384437ce270f008da/pyproject.toml#L40) file. +- Use the `tutorial` requirements in the [`pyproject.toml`](https://github.com/PINA-org/PINA/blob/6ed3ca04fee3ae3673d53ea384437ce270f008da/pyproject.toml#L40) file. ## Contributing Checklist diff --git a/tutorials/tutorial1/tutorial.ipynb b/tutorials/tutorial1/tutorial.ipynb index 3239206d4..243992e29 100644 --- a/tutorials/tutorial1/tutorial.ipynb +++ b/tutorials/tutorial1/tutorial.ipynb @@ -7,10 +7,10 @@ "metadata": {}, "source": [ "# Tutorial: Introductory Tutorial: Physics Informed Neural Networks with PINA \n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial1/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial1/tutorial.ipynb)\n", "\n", "> ##### ⚠️ ***Before starting:***\n", - "> We assume you are already familiar with the concepts covered in the [Getting started with PINA](https://mathlab.github.io/PINA/_tutorial.html#getting-started-with-pina) tutorials. If not, we strongly recommend reviewing them before exploring this advanced topic.\n" + "> We assume you are already familiar with the concepts covered in the [Getting started with PINA](https://PINA-org.github.io/PINA/_tutorial.html#getting-started-with-pina) tutorials. If not, we strongly recommend reviewing them before exploring this advanced topic.\n" ] }, { @@ -19,7 +19,7 @@ "id": "ef4949c9", "metadata": {}, "source": [ - "In this tutorial, we will demonstrate a typical use case of **PINA** for Physics-Informed training. We will cover the basics of training a `PhysicsInformedSingleModelSolver` with PINA, if you want to go further into Physics-Informed solvers look at our dedicated [tutorials](https://mathlab.github.io/PINA/_tutorial.html#physics-informed-neural-networks) on the topic.\n", + "In this tutorial, we will demonstrate a typical use case of **PINA** for Physics-Informed training. We will cover the basics of training a `PhysicsInformedSingleModelSolver` with PINA, if you want to go further into Physics-Informed solvers look at our dedicated [tutorials](https://PINA-org.github.io/PINA/_tutorial.html#physics-informed-neural-networks) on the topic.\n", "\n", "Let's start by importing the useful modules:" ] @@ -232,13 +232,13 @@ "Once the problem is defined and the data is generated, we can move on to modeling. This process consists of three key steps:\n", "\n", "**Choosing a Model**\n", - "- Select a neural network architecture. You can use the model we provide in the `pina.model` module (see [here](https://mathlab.github.io/PINA/_rst/_code.html#models) for a full list), or define a custom PyTorch module (more on this [here](https://pytorch.org/docs/stable/notes/modules.html)).\n", + "- Select a neural network architecture. You can use the model we provide in the `pina.model` module (see [here](https://PINA-org.github.io/PINA/_rst/_code.html#models) for a full list), or define a custom PyTorch module (more on this [here](https://pytorch.org/docs/stable/notes/modules.html)).\n", "\n", "**Choosing a Physics-Informed Solver & Defining the Trainer**\n", - "* Use a Physics-Informed solver from `pina.solver` module to solve the problem using the specified model. We have already implemented most State-Of-The-Arte solvers for you, [have a look](https://mathlab.github.io/PINA/_rst/_code.html#solvers) if interested. Today we will use the standard `PhysicsInformedSingleModelSolver` solver.\n", + "* Use a Physics-Informed solver from `pina.solver` module to solve the problem using the specified model. We have already implemented most State-Of-The-Arte solvers for you, [have a look](https://PINA-org.github.io/PINA/_rst/_code.html#solvers) if interested. Today we will use the standard `PhysicsInformedSingleModelSolver` solver.\n", "\n", "**Training**\n", - "* Train the model with the [`Trainer`](https://mathlab.github.io/PINA/_rst/trainer.html) class. The Trainer class provides powerful features to enhance model accuracy, optimize training time and memory, and simplify logging and visualization, thanks to PyTorch Lightning's excellent work, see [our dedicated tutorial](https://mathlab.github.io/PINA/tutorial11/tutorial.html) for further details. By default, training metrics (e.g., MSE error) are logged using a lightning logger (CSVLogger). If you prefer manual tracking, use `pina.callback.MetricTracker`.\n", + "* Train the model with the [`Trainer`](https://PINA-org.github.io/PINA/_rst/trainer.html) class. The Trainer class provides powerful features to enhance model accuracy, optimize training time and memory, and simplify logging and visualization, thanks to PyTorch Lightning's excellent work, see [our dedicated tutorial](https://PINA-org.github.io/PINA/tutorial11/tutorial.html) for further details. By default, training metrics (e.g., MSE error) are logged using a lightning logger (CSVLogger). If you prefer manual tracking, use `pina.callback.MetricTracker`.\n", "\n", "Let's cover all steps one by one!\n", "\n", @@ -269,7 +269,7 @@ "Then we build the solver. The `PhysicsInformedSingleModelSolver` class needs to be initialized with a `model` and a specific `problem` to be solved. They also take extra arguments, as the optimizer, scheduler, loss type and weighting for the different conditions which are all set to their default values.\n", "\n", ">##### 💡***Bonus tip:***\n", - "> All physics solvers in PINA can handle both forward and inverse problems without requiring any changes to the model or solver structure! See [our tutorial](https://mathlab.github.io/PINA/tutorial7/tutorial.html) of inverse problems for more infos." + "> All physics solvers in PINA can handle both forward and inverse problems without requiring any changes to the model or solver structure! See [our tutorial](https://PINA-org.github.io/PINA/tutorial7/tutorial.html) of inverse problems for more infos." ] }, { @@ -411,7 +411,7 @@ "\n", "5. **... and many more!**: The possibilities are vast! Continue experimenting with advanced configurations, solvers, and other features in PINA.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial10/tutorial.ipynb b/tutorials/tutorial10/tutorial.ipynb index f94f336ec..0e3bbcc4d 100644 --- a/tutorials/tutorial10/tutorial.ipynb +++ b/tutorials/tutorial10/tutorial.ipynb @@ -6,7 +6,7 @@ "source": [ "# Tutorial: Solving the Kuramoto–Sivashinsky Equation with Averaging Neural Operator\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial10/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial10/tutorial.ipynb)\n", "\n", "\n", "In this tutorial, we will build a Neural Operator using the **`AveragingNeuralOperator`** model and the **`SupervisedSingleModelSolver`**. By the end of this tutorial, you will be able to train a Neural Operator to learn the operator for time-dependent PDEs.\n", @@ -31,8 +31,8 @@ " !pip install \"pina-mathlab[tutorial]\"\n", " # get the data\n", " !mkdir \"data\"\n", - " !wget \"https://github.com/mathLab/PINA/raw/refs/heads/master/tutorials/tutorial10/data/Data_KS.mat\" -O \"data/Data_KS.mat\"\n", - " !wget \"https://github.com/mathLab/PINA/raw/refs/heads/master/tutorials/tutorial10/data/Data_KS2.mat\" -O \"data/Data_KS2.mat\"\n", + " !wget \"https://github.com/PINA-org/PINA/raw/refs/heads/master/tutorials/tutorial10/data/Data_KS.mat\" -O \"data/Data_KS.mat\"\n", + " !wget \"https://github.com/PINA-org/PINA/raw/refs/heads/master/tutorials/tutorial10/data/Data_KS2.mat\" -O \"data/Data_KS2.mat\"\n", "\n", "import torch\n", "import matplotlib.pyplot as plt\n", @@ -208,7 +208,7 @@ "\\texttt{NO}_\\theta[u(t=0)](x, t) \\rightarrow u(x, t).\n", "$$\n", "\n", - "There are many ways to approximate the following operator, for example, by using a 2D [FNO](https://mathlab.github.io/PINA/_rst/model/fourier_neural_operator.html) (for regular meshes), a [DeepOnet](https://mathlab.github.io/PINA/_rst/model/deeponet.html), [Continuous Convolutional Neural Operator](https://mathlab.github.io/PINA/_rst/model/block/convolution.html), or [MIONet](https://mathlab.github.io/PINA/_rst/model/mionet.html). In this tutorial, we will use the *Averaging Neural Operator* presented in [*The Nonlocal Neural Operator: Universal Approximation*](https://arxiv.org/abs/2304.13221), which is a [Kernel Neural Operator](https://mathlab.github.io/PINA/_rst/model/kernel_neural_operator.html) with an integral kernel:\n", + "There are many ways to approximate the following operator, for example, by using a 2D [FNO](https://PINA-org.github.io/PINA/_rst/model/fourier_neural_operator.html) (for regular meshes), a [DeepOnet](https://PINA-org.github.io/PINA/_rst/model/deeponet.html), [Continuous Convolutional Neural Operator](https://PINA-org.github.io/PINA/_rst/model/block/convolution.html), or [MIONet](https://PINA-org.github.io/PINA/_rst/model/mionet.html). In this tutorial, we will use the *Averaging Neural Operator* presented in [*The Nonlocal Neural Operator: Universal Approximation*](https://arxiv.org/abs/2304.13221), which is a [Kernel Neural Operator](https://PINA-org.github.io/PINA/_rst/model/kernel_neural_operator.html) with an integral kernel:\n", "\n", "$$\n", "K(v) = \\sigma\\left(Wv(x) + b + \\frac{1}{|\\Omega|}\\int_\\Omega v(y)dy\\right)\n", @@ -221,9 +221,9 @@ "* $W \\in \\mathbb{R}^{\\rm{emb} \\times \\rm{emb}}$ is a tunable matrix.\n", "* $b \\in \\mathbb{R}^{\\rm{emb}}$ is a tunable bias.\n", "\n", - "In PINA, many Kernel Neural Operators are already implemented. The modular components of the [Kernel Neural Operator](https://mathlab.github.io/PINA/_rst/model/kernel_neural_operator.html) class allow you to create new ones by composing base kernel layers.\n", + "In PINA, many Kernel Neural Operators are already implemented. The modular components of the [Kernel Neural Operator](https://PINA-org.github.io/PINA/_rst/model/kernel_neural_operator.html) class allow you to create new ones by composing base kernel layers.\n", "\n", - "**Note:** We will use the already built class `AveragingNeuralOperator`. As a constructive exercise, try to use the [KernelNeuralOperator](https://mathlab.github.io/PINA/_rst/model/kernel_neural_operator.html) class to build a kernel neural operator from scratch. You might employ the different layers that we have in PINA, such as [FeedForward](https://mathlab.github.io/PINA/_rst/model/feed_forward.html) and [AveragingNeuralOperator](https://mathlab.github.io/PINA/_rst/model/average_neural_operator.html) layers." + "**Note:** We will use the already built class `AveragingNeuralOperator`. As a constructive exercise, try to use the [KernelNeuralOperator](https://PINA-org.github.io/PINA/_rst/model/kernel_neural_operator.html) class to build a kernel neural operator from scratch. You might employ the different layers that we have in PINA, such as [FeedForward](https://PINA-org.github.io/PINA/_rst/model/feed_forward.html) and [AveragingNeuralOperator](https://PINA-org.github.io/PINA/_rst/model/average_neural_operator.html) layers." ] }, { @@ -260,7 +260,7 @@ "\n", "## Solving the KS problem\n", "\n", - "We will now focus on solving the KS equation using the `SupervisedSingleModelSolver` class and the `AveragingNeuralOperator` model. As done in the [FNO tutorial](https://github.com/mathLab/PINA/blob/master/tutorials/tutorial5/tutorial.ipynb), we now create the Neural Operator problem class with `SupervisedProblem`." + "We will now focus on solving the KS equation using the `SupervisedSingleModelSolver` class and the `AveragingNeuralOperator` model. As done in the [FNO tutorial](https://github.com/PINA-org/PINA/blob/master/tutorials/tutorial5/tutorial.ipynb), we now create the Neural Operator problem class with `SupervisedProblem`." ] }, { @@ -364,9 +364,9 @@ "\n", "2. **Use a more challenging dataset**: Try using the more complex dataset [Data_KS2.mat](dat/Data_KS2.mat) where $A_k \\in [-0.5, 0.5]$, $\\ell_k \\in [1, 2, 3]$, and $\\phi_k \\in [0, 2\\pi]$ for a more difficult task. This dataset may require longer training and testing.\n", "\n", - "3. **... and many more...**: Explore other models, such as the [FNO](https://mathlab.github.io/PINA/_rst/models/fno.html), [DeepOnet](https://mathlab.github.io/PINA/_rst/models/deeponet.html), or implement your own operator using the [KernelNeuralOperator](https://mathlab.github.io/PINA/_rst/models/base_no.html) class to compare performance and find the best model for your task.\n", + "3. **... and many more...**: Explore other models, such as the [FNO](https://PINA-org.github.io/PINA/_rst/models/fno.html), [DeepOnet](https://PINA-org.github.io/PINA/_rst/models/deeponet.html), or implement your own operator using the [KernelNeuralOperator](https://PINA-org.github.io/PINA/_rst/models/base_no.html) class to compare performance and find the best model for your task.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial11/tutorial.ipynb b/tutorials/tutorial11/tutorial.ipynb index 3ae863a2b..379157e55 100644 --- a/tutorials/tutorial11/tutorial.ipynb +++ b/tutorials/tutorial11/tutorial.ipynb @@ -5,9 +5,9 @@ "metadata": {}, "source": [ "# Tutorial: Introduction to `Trainer` class\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial11/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial11/tutorial.ipynb)\n", "\n", - "In this tutorial, we will delve deeper into the functionality of the `Trainer` class, which serves as the cornerstone for training **PINA** [Solvers](https://mathlab.github.io/PINA/_rst/_code.html#solvers). \n", + "In this tutorial, we will delve deeper into the functionality of the `Trainer` class, which serves as the cornerstone for training **PINA** [Solvers](https://PINA-org.github.io/PINA/_rst/_code.html#solvers). \n", "\n", "The `Trainer` class offers a plethora of features aimed at improving model accuracy, reducing training time and memory usage, facilitating logging visualization, and more thanks to the amazing job done by the PyTorch Lightning team!\n", "\n", @@ -132,7 +132,7 @@ "source": [ "## Trainer Logging\n", "\n", - "In **PINA** you can log metrics in different ways. The simplest approach is to use the `MetricTracker` class from `pina.callback`, as seen in the [*Introduction to Physics Informed Neural Networks training*](https://github.com/mathLab/PINA/blob/master/tutorials/tutorial1/tutorial.ipynb) tutorial.\n", + "In **PINA** you can log metrics in different ways. The simplest approach is to use the `MetricTracker` class from `pina.callback`, as seen in the [*Introduction to Physics Informed Neural Networks training*](https://github.com/PINA-org/PINA/blob/master/tutorials/tutorial1/tutorial.ipynb) tutorial.\n", "\n", "However, especially when we need to train multiple times to get an average of the loss across multiple runs, `lightning.pytorch.loggers` might be useful. Here we will use `TensorBoardLogger` (more on [logging](https://lightning.ai/docs/pytorch/stable/extensions/logging.html) here), but you can choose the one you prefer (or make your own one).\n", "\n", @@ -182,7 +182,7 @@ "metadata": {}, "source": [ "

\n", - " \\\"Logging\n", + " \\\"Logging\n", "

" ] }, @@ -473,7 +473,7 @@ "\n", "4. **...and many more!**: Consider expanding to **multi-GPU** setups or other advanced configurations for large-scale training.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/).\n" + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/).\n" ] } ], diff --git a/tutorials/tutorial12/tutorial.ipynb b/tutorials/tutorial12/tutorial.ipynb index c3d957c2c..2d6c0806f 100644 --- a/tutorials/tutorial12/tutorial.ipynb +++ b/tutorials/tutorial12/tutorial.ipynb @@ -6,7 +6,7 @@ "source": [ "# Tutorial: Introduction to PINA `Equation` class\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial12/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial12/tutorial.ipynb)\n", "\n", "\n", "In this tutorial, we will explore how to use the `Equation` class in **PINA**. We will focus on how to leverage this class, along with its inherited subclasses, to enforce residual minimization in **Physics-Informed Solvers**.\n", @@ -99,7 +99,7 @@ "\n", "Let's define now the problem!\n", "\n", - "> **👉 Do you want to learn more on Problems? Check the dedicated [tutorial](https://mathlab.github.io/PINA/tutorial16/tutorial.html) to learn how to build a Problem from scratch.**" + "> **👉 Do you want to learn more on Problems? Check the dedicated [tutorial](https://PINA-org.github.io/PINA/tutorial16/tutorial.html) to learn how to build a Problem from scratch.**" ] }, { @@ -243,7 +243,7 @@ "- **Integrate Custom Equations and Operators**: Combine your custom equations and operators into larger systems for more complex simulations.\n", "- **and many more!**: Explore for example different residual minimization techniques to improve the performance and accuracy of your models.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial13/tutorial.ipynb b/tutorials/tutorial13/tutorial.ipynb index 7c8928110..bda460653 100644 --- a/tutorials/tutorial13/tutorial.ipynb +++ b/tutorials/tutorial13/tutorial.ipynb @@ -6,7 +6,7 @@ "source": [ "# Tutorial: Learning Multiscale PDEs Using Fourier Feature Networks\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial13/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial13/tutorial.ipynb)\n", "\n", "This tutorial demonstrates how to solve a PDE with multiscale behavior using Physics-Informed Neural Networks (PINNs), as discussed in [*On the Eigenvector Bias of Fourier Feature Networks: From Regression to Solving Multi-Scale PDEs with Physics-Informed Neural Networks*](https://doi.org/10.1016/j.cma.2021.113938).\n", "\n", @@ -78,7 +78,7 @@ "While this example is simple and pedagogical, it's important to note that the solution exhibits low-frequency behavior in the macro-scale and high-frequency behavior in the micro-scale. This characteristic is common in many practical scenarios.\n", "\n", "Below is the implementation of the `Poisson` problem as described mathematically above.\n", - "> **👉 We have a dedicated [tutorial](https://mathlab.github.io/PINA/tutorial16/tutorial.html) to teach how to build a Problem from scratch — have a look if you're interested!**" + "> **👉 We have a dedicated [tutorial](https://PINA-org.github.io/PINA/tutorial16/tutorial.html) to teach how to build a Problem from scratch — have a look if you're interested!**" ] }, { @@ -131,7 +131,7 @@ "\n", "However, solving high-frequency or multi-scale problems presents significant challenges to PINNs, especially when the number of data points is insufficient to capture the different scales effectively.\n", "\n", - "Below, we run a simulation using both the `PhysicsInformedSingleModelSolver` solver and the `SelfAdaptivePhysicsInformedSolver` solver, employing a [`FeedForward`](https://mathlab.github.io/PINA/_modules/pina/model/feed_forward.html#FeedForward) model.\n" + "Below, we run a simulation using both the `PhysicsInformedSingleModelSolver` solver and the `SelfAdaptivePhysicsInformedSolver` solver, employing a [`FeedForward`](https://PINA-org.github.io/PINA/_modules/pina/model/feed_forward.html#FeedForward) model.\n" ] }, { @@ -249,7 +249,7 @@ "\n", "where $\\mathbf{B}_{ij} \\sim \\mathcal{N}(0, \\sigma^2)$. This simple operation allows the network to learn across multiple scales!\n", "\n", - "In **PINA**, we have already implemented this feature as a `layer` called [`FourierFeatureEmbedding`](https://mathlab.github.io/PINA/_rst/layers/fourier_embedding.html). Below, we will build the *Multi-scale Fourier Feature Architecture*. In this architecture, multiple Fourier feature embeddings (initialized with different $\\sigma$ values) are applied to the input coordinates. These embeddings are then passed through the same fully-connected neural network, and the outputs are concatenated with a final linear layer.\n" + "In **PINA**, we have already implemented this feature as a `layer` called [`FourierFeatureEmbedding`](https://PINA-org.github.io/PINA/_rst/layers/fourier_embedding.html). Below, we will build the *Multi-scale Fourier Feature Architecture*. In this architecture, multiple Fourier feature embeddings (initialized with different $\\sigma$ values) are applied to the input coordinates. These embeddings are then passed through the same fully-connected neural network, and the outputs are concatenated with a final linear layer.\n" ] }, { @@ -348,7 +348,7 @@ "\n", "4. **...and many more!**: There are countless directions to further explore, from testing on different problems to refining the model architecture.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial14/tutorial.ipynb b/tutorials/tutorial14/tutorial.ipynb index a12168383..bdd376eef 100644 --- a/tutorials/tutorial14/tutorial.ipynb +++ b/tutorials/tutorial14/tutorial.ipynb @@ -6,7 +6,7 @@ "source": [ "# Tutorial: Learning Bifurcating PDE Solutions with Physics-Informed Deep Ensembles\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial14/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial14/tutorial.ipynb)\n", "\n", "This tutorial demonstrates how to use the Deep Ensemble Physics Informed Network (DeepEnsemblePINN) to learn PDEs exhibiting bifurcating behavior, as discussed in [*Learning and Discovering Multiple Solutions Using Physics-Informed Neural Networks with Random Initialization and Deep Ensemble*](https://arxiv.org/abs/2503.06320).\n", "\n", @@ -58,7 +58,7 @@ "This approach allows the ensemble to capture different perspectives of the problem, leading to more accurate and reliable predictions.\n", "\n", "

\n", - " \"Deep\n", + " \"Deep\n", "

\n", "\n", "The image above illustrates an Ensemble setup, where multiple models attempt to predict the text from an image. While individual models may make errors (e.g., predicting \"PONY\" instead of \"PINA\"), combining their outputs—such as taking the majority vote—often leads to the correct result. This ensemble effect improves reliability by mitigating the impact of individual model biases.\n", @@ -106,9 +106,9 @@ "\n", "We first write the problem class, we do not write the boundary conditions as we will hard impose them.\n", "\n", - "> **👉 We have a dedicated [tutorial](https://mathlab.github.io/PINA/tutorial16/tutorial.html) to teach how to build a Problem — have a look if you're interested!**\n", + "> **👉 We have a dedicated [tutorial](https://PINA-org.github.io/PINA/tutorial16/tutorial.html) to teach how to build a Problem — have a look if you're interested!**\n", "\n", - "> **👉 We have a dedicated [tutorial](https://mathlab.github.io/PINA/tutorial3/tutorial.html) to teach how to impose hard constraints — have a look if you're interested!**" + "> **👉 We have a dedicated [tutorial](https://PINA-org.github.io/PINA/tutorial3/tutorial.html) to teach how to impose hard constraints — have a look if you're interested!**" ] }, { @@ -346,7 +346,7 @@ "\n", "3. **...and many more!**: There are countless directions to further explore, for example, what does it happen when you vary the network initialization hyperparameters?\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial15/tutorial.ipynb b/tutorials/tutorial15/tutorial.ipynb index 1de5cab3e..25993be55 100644 --- a/tutorials/tutorial15/tutorial.ipynb +++ b/tutorials/tutorial15/tutorial.ipynb @@ -6,7 +6,7 @@ "source": [ "# Tutorial: Chemical Properties Prediction with Graph Neural Networks\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial15/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial15/tutorial.ipynb)\n", "\n", "In this tutorial we will use **Graph Neural Networks** (GNNs) for chemical properties prediction. Chemical properties prediction involves estimating or determining the physical, chemical, or biological characteristics of molecules based on their structure. \n", "\n", @@ -106,7 +106,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Great! Once the data are downloaded, building the problem is straightforward by using the [`SupervisedProblem`](https://mathlab.github.io/PINA/_rst/problem/zoo/supervised_problem.html) class." + "Great! Once the data are downloaded, building the problem is straightforward by using the [`SupervisedProblem`](https://PINA-org.github.io/PINA/_rst/problem/zoo/supervised_problem.html) class." ] }, { @@ -159,7 +159,7 @@ "source": [ "## Train the Model\n", "\n", - "Now that the problem is created and the model is built, we can train the model using the [`SupervisedSingleModelSolver`](https://mathlab.github.io/PINA/_rst/solver/supervised.html), which is the solver for standard supervised learning task. We will optimize the Maximum Absolute Error and test on the same metric. In the [`Trainer`](https://mathlab.github.io/PINA/_rst/trainer.html) class we specify the optimization hyperparameters." + "Now that the problem is created and the model is built, we can train the model using the [`SupervisedSingleModelSolver`](https://PINA-org.github.io/PINA/_rst/solver/supervised.html), which is the solver for standard supervised learning task. We will optimize the Maximum Absolute Error and test on the same metric. In the [`Trainer`](https://PINA-org.github.io/PINA/_rst/trainer.html) class we specify the optimization hyperparameters." ] }, { @@ -210,7 +210,7 @@ "source": [ "We observe that the model achieves an average error of approximately 0.4 MAE across all property predictions. This error is an average, but we can also inspect the error for each individual property prediction.\n", "\n", - "To do this, we need access to the test dataset, which can be retrieved from the trainer's datamodule. Each datamodule contains both the dataloader and dataset objects. For the dataset, we can use the [`get_all_data()`](https://mathlab.github.io/PINA/_rst/data/dataset.html#pina.data.dataset.PinaDataset.get_all_data) method. This function returns the entire dataset as a dictionary, where the keys represent the Condition names, and the values are dictionaries containing input and target tensors." + "To do this, we need access to the test dataset, which can be retrieved from the trainer's datamodule. Each datamodule contains both the dataloader and dataset objects. For the dataset, we can use the [`get_all_data()`](https://PINA-org.github.io/PINA/_rst/data/dataset.html#pina.data.dataset.PinaDataset.get_all_data) method. This function returns the entire dataset as a dictionary, where the keys represent the Condition names, and the values are dictionaries containing input and target tensors." ] }, { @@ -408,7 +408,7 @@ "\n", "4. **...and many more!**: The possibilities are vast, including exploring new architectures, working with larger datasets, and applying this framework to more complex systems.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial16/tutorial.ipynb b/tutorials/tutorial16/tutorial.ipynb index 138945177..fc6b2cdc4 100644 --- a/tutorials/tutorial16/tutorial.ipynb +++ b/tutorials/tutorial16/tutorial.ipynb @@ -8,7 +8,7 @@ "source": [ "# Tutorial: How to build a Problem in PINA\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial16/tutorial.ipynb)\n" + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial16/tutorial.ipynb)\n" ] }, { @@ -88,9 +88,9 @@ "\n", " # other stuff ...\n", "```\n", - "Observe that we define `input_variables` and `output_variables` as lists of symbols. This is because, in PINA, `torch.Tensors` can be labeled (see [`LabelTensor`](https://mathlab.github.io/PINA/_rst/label_tensor.html)), providing maximum flexibility for tensor manipulation. If you prefer to use regular tensors, you can simply set these to ``None``.\n", + "Observe that we define `input_variables` and `output_variables` as lists of symbols. This is because, in PINA, `torch.Tensors` can be labeled (see [`LabelTensor`](https://PINA-org.github.io/PINA/_rst/label_tensor.html)), providing maximum flexibility for tensor manipulation. If you prefer to use regular tensors, you can simply set these to ``None``.\n", "\n", - "To specify the input and target data, you need to use the [`Condition`](https://mathlab.github.io/PINA/_rst/condition/condition.html) interface. A condition defines the constraints (such as physical equations, boundary conditions, etc.) that must be satisfied within the problem. Once the condition is applied, the full problem is outlined below:" + "To specify the input and target data, you need to use the [`Condition`](https://PINA-org.github.io/PINA/_rst/condition/condition.html) interface. A condition defines the constraints (such as physical equations, boundary conditions, etc.) that must be satisfied within the problem. Once the condition is applied, the full problem is outlined below:" ] }, { @@ -150,7 +150,7 @@ "id": "59d80694", "metadata": {}, "source": [ - ">👉 **You can use multiple data structures in PINA conditions, including `Graph` or `Data` from `PyG`. To explore the different data structures available in PINA, check out [this tutorial](), and for more information on input-target conditions, visit the conditions factory classes [here](https://mathlab.github.io/PINA/_rst/condition/input_target_condition.html)**." + ">👉 **You can use multiple data structures in PINA conditions, including `Graph` or `Data` from `PyG`. To explore the different data structures available in PINA, check out [this tutorial](), and for more information on input-target conditions, visit the conditions factory classes [here](https://PINA-org.github.io/PINA/_rst/condition/input_target_condition.html)**." ] }, { @@ -175,7 +175,7 @@ "* `SpatialProblem` $\\rightarrow$ a differential equation with spatial variable(s)\n", "* `TimeDependentProblem` $\\rightarrow$ a time-dependent differential equation with temporal variable(s)\n", "* `ParametricProblem` $\\rightarrow$ a parametrized differential equation with parametric variable(s)\n", - "* `InverseProblem` $\\rightarrow$ this is a more advanced topic, see [this tutorial](https://mathlab.github.io/PINA/tutorial7/tutorial.html) for more details.\n", + "* `InverseProblem` $\\rightarrow$ this is a more advanced topic, see [this tutorial](https://PINA-org.github.io/PINA/tutorial7/tutorial.html) for more details.\n", "\n", "In our case, the physical ODE inherits from the `SpatialProblem` class, since only spatial variables define the ODE.\n", "\n", @@ -201,7 +201,7 @@ " # other stuff ...\n", "```\n", "\n", - "Differently from data-driven problems, differential-problems need to specify the domain type. If you look at our ODE definition, the spatial varibale $x$ is defined in the interval $(0,1)$, and accordingly the `spatial_domain` is a `CartesianDomain` with the input variable `x` in `[0,1]`. To know more about the Domain class see the [related tutorial](https://mathlab.github.io/PINA/tutorial6/tutorial.html). Different problems require different domain, here below we summarize the relevant ones:\n", + "Differently from data-driven problems, differential-problems need to specify the domain type. If you look at our ODE definition, the spatial varibale $x$ is defined in the interval $(0,1)$, and accordingly the `spatial_domain` is a `CartesianDomain` with the input variable `x` in `[0,1]`. To know more about the Domain class see the [related tutorial](https://PINA-org.github.io/PINA/tutorial6/tutorial.html). Different problems require different domain, here below we summarize the relevant ones:\n", "\n", "| Problem Type | Required Domain |\n", "|-------------------------|--------------------------------|\n", @@ -274,17 +274,17 @@ "id": "7cf64d01", "metadata": {}, "source": [ - "As you can see, we implemented the `ode_equation` function which given the model ouput and input returns the equation residual. These residuals are the ones minimized during PINN optimization (for more on PINN see [the related tutorials](https://mathlab.github.io/PINA/_tutorial.html#physics-informed-neural-networks)). \n", + "As you can see, we implemented the `ode_equation` function which given the model ouput and input returns the equation residual. These residuals are the ones minimized during PINN optimization (for more on PINN see [the related tutorials](https://PINA-org.github.io/PINA/_tutorial.html#physics-informed-neural-networks)). \n", "\n", "How are the residuals computed?\n", - "Given the output we perform differential operation using the [operator modulus](https://mathlab.github.io/PINA/_rst/operator.html). It is pretty intuitive, each differential operator takes the following inputs: \n", + "Given the output we perform differential operation using the [operator modulus](https://PINA-org.github.io/PINA/_rst/operator.html). It is pretty intuitive, each differential operator takes the following inputs: \n", "- A tensor on which the operator is applied. \n", "- A tensor with respect to which the operator is computed. \n", "- The names of the output variables for which the operator is evaluated. \n", "- The names of the variables with respect to which the operator is computed.\n", "We also have a `fast` version of differential operators, where no checks are performed. This can be used to boost performances, once you know the standard ones are doing their job. \n", "\n", - "Notice that we do not pass directly a `python` function, but an `Equation` object, which is initialized with the `python` function. This is done so that all the computations and internal checks are done inside **PINA**, see [the related tutorials](https://mathlab.github.io/PINA/tutorial12/tutorial.html) for more.\n", + "Notice that we do not pass directly a `python` function, but an `Equation` object, which is initialized with the `python` function. This is done so that all the computations and internal checks are done inside **PINA**, see [the related tutorials](https://PINA-org.github.io/PINA/tutorial12/tutorial.html) for more.\n", "\n", "Once we have defined the function, we need to tell the neural network where these methods are to be applied. To do so, we use again the `Condition` class. In the `Condition` class, we pass the location points and the equation we want minimized on those points.\n", "\n", @@ -428,7 +428,7 @@ "source": [ "## The Problem Zoo module\n", "\n", - "In PINA many problems are already implemented for you in the [Problem Zoo module](https://mathlab.github.io/PINA/_rst/_code.html#problems-zoo). For example, the supervised problem at the beginning of the tutorial is implemented in [`SupervisedProblem`](https://mathlab.github.io/PINA/_rst/problem/zoo/supervised_problem.html)!\n", + "In PINA many problems are already implemented for you in the [Problem Zoo module](https://PINA-org.github.io/PINA/_rst/_code.html#problems-zoo). For example, the supervised problem at the beginning of the tutorial is implemented in [`SupervisedProblem`](https://PINA-org.github.io/PINA/_rst/problem/zoo/supervised_problem.html)!\n", "\n", "Let's see now a physics based example, the advection equation" ] @@ -466,11 +466,11 @@ "\n", "1. **Create Custom Problems**: Try building your own problems using the PINA framework, experiment with different PDEs, initial/boundary conditions, and data structures.\n", "\n", - "2. **Explore the Problem Zoo**: Dive into the [`problem.zoo` module](https://mathlab.github.io/PINA/_rst/_code.html#problems-zoo) to find a variety of predefined problem setups and use them as a starting point or inspiration for your own.\n", + "2. **Explore the Problem Zoo**: Dive into the [`problem.zoo` module](https://PINA-org.github.io/PINA/_rst/_code.html#problems-zoo) to find a variety of predefined problem setups and use them as a starting point or inspiration for your own.\n", "\n", "3. **...and many more!**: The possibilities are vast! Consider experimenting with different solver strategies, model architectures, or even implementing your own physical constraints.\n", "\n", - "For more examples and in-depth guides, be sure to check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more examples and in-depth guides, be sure to check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial17/tutorial.ipynb b/tutorials/tutorial17/tutorial.ipynb index 8195ca0c1..b4ed926c5 100644 --- a/tutorials/tutorial17/tutorial.ipynb +++ b/tutorials/tutorial17/tutorial.ipynb @@ -8,10 +8,10 @@ "source": [ "# Tutorial: Introductory Tutorial: A Beginner’s Guide to PINA\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial17/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial17/tutorial.ipynb)\n", "\n", "

\n", - " \"PINA\n", + " \"PINA\n", "

\n", "\n", "\n", @@ -39,7 +39,7 @@ "## The PINA Workflow \n", "\n", "

\n", - " \"PINA\n", + " \"PINA\n", "

\n", "\n", "Solving a differential problem in **PINA** involves four main steps:\n", @@ -53,7 +53,7 @@ "\n", " Then prepare inputs by discretizing the domain or importing numerical data. PINA provides essential tools like the `Condition` class and the `pina.domain` module to facilitate domain sampling and ensure that the input data aligns with the problem's requirements.\n", "\n", - "> **👉 We have a dedicated [tutorial](https://mathlab.github.io/PINA/tutorial16/tutorial.html) to teach how to build a Problem from scratch — have a look if you're interested!**\n", + "> **👉 We have a dedicated [tutorial](https://PINA-org.github.io/PINA/tutorial16/tutorial.html) to teach how to build a Problem from scratch — have a look if you're interested!**\n", "\n", "2. ***Model Design*** \n", " Build neural network models as **PyTorch modules**. For graph-structured data, use **PyTorch Geometric** to build Graph Neural Networks. You can also import models from `pina.model` module!\n", @@ -213,7 +213,7 @@ "#### ***Model Design***\n", "\n", "We will now solve the problem using a **simple PyTorch Neural Network** with **Dropout**, which we will implement from scratch following [2]. \n", - "It's important to note that PINA provides a wide range of **state-of-the-art (SOTA)** architectures in the `pina.model` module, which you can explore further [here](https://mathlab.github.io/PINA/_rst/_code.html#models).\n", + "It's important to note that PINA provides a wide range of **state-of-the-art (SOTA)** architectures in the `pina.model` module, which you can explore further [here](https://PINA-org.github.io/PINA/_rst/_code.html#models).\n", "\n", "#### ***Solver Selection***\n", "\n", @@ -339,7 +339,7 @@ "\n", "### Solving a 2D Poisson Problem\n", "\n", - "In this section, we will solve a **2D Poisson problem** with **Dirichlet boundary conditions** on an **hourglass-shaped domain** using a simple `PhysicsInformedSingleModelSolver` [4]. You can explore other PINN variants, e.g. [5] or [6] in PINA by visiting the [PINA solvers documentation](https://mathlab.github.io/PINA/_rst/_code.html#solvers). We aim to solve the following 2D Poisson problem:\n", + "In this section, we will solve a **2D Poisson problem** with **Dirichlet boundary conditions** on an **hourglass-shaped domain** using a simple `PhysicsInformedSingleModelSolver` [4]. You can explore other PINN variants, e.g. [5] or [6] in PINA by visiting the [PINA solvers documentation](https://PINA-org.github.io/PINA/_rst/_code.html#solvers). We aim to solve the following 2D Poisson problem:\n", "\n", "$$\n", "\\begin{cases}\n", @@ -354,7 +354,7 @@ "\n", "PINA allows you to build complex geometries easily. It provides many built-in domain shapes and Boolean operators for combining them. For this problem, we will define the hourglass-shaped domain using the existing `CartesianDomain` and `EllipsoidDomain` classes, with Boolean operators like `Difference` and `Union`.\n", "\n", - "> **👉 If you are interested in exploring the `domain` module in more detail, check out [this tutorial](https://mathlab.github.io/PINA/_rst/tutorials/tutorial6/tutorial.html).**\n" + "> **👉 If you are interested in exploring the `domain` module in more detail, check out [this tutorial](https://PINA-org.github.io/PINA/_rst/tutorials/tutorial6/tutorial.html).**\n" ] }, { @@ -493,7 +493,7 @@ "- We inherit from **`SpatialProblem`** instead of `BaseProblem` to account for spatial variables.\n", "- We use **`domain`** and **`equation`** inside the `Condition` to define the problem.\n", "\n", - "The `Equation` class can be very useful for creating modular problem classes. If you're interested, check out [this tutorial](https://mathlab.github.io/PINA/_rst/tutorial12/tutorial.html) for more details. There's also a dedicated [tutorial](https://mathlab.github.io/PINA/_rst/tutorial16/tutorial.html) for building custom problems!\n", + "The `Equation` class can be very useful for creating modular problem classes. If you're interested, check out [this tutorial](https://PINA-org.github.io/PINA/_rst/tutorial12/tutorial.html) for more details. There's also a dedicated [tutorial](https://PINA-org.github.io/PINA/_rst/tutorial16/tutorial.html) for building custom problems!\n", "\n", "Once the problem class is set, we need to **sample the domain** to obtain the data. PINA will automatically handle this, and if you forget to sample, an error will be raised before training begins 😉." ] @@ -522,7 +522,7 @@ "\n", "After setting the problem and sampling the domain, the next step is to **build the model** $\\mathcal{M}_{\\theta}$.\n", "\n", - "For this, we will use the custom PINA models available [here](https://mathlab.github.io/PINA/_rst/_code.html#models). Specifically, we will use a **feed-forward neural network** by importing the `FeedForward` class.\n", + "For this, we will use the custom PINA models available [here](https://PINA-org.github.io/PINA/_rst/_code.html#models). Specifically, we will use a **feed-forward neural network** by importing the `FeedForward` class.\n", "\n", "This neural network takes the **coordinates** (in this case `['x', 'y']`) as input and outputs the unknown field of the Poisson problem. \n", "\n", @@ -572,11 +572,11 @@ "\n", "### Training\n", "\n", - "For the last part of the pipeline we need a `Trainer`. We will train the model for **1500 epochs** using the default optimizer parameters. These parameters can be adjusted as needed. For more details, check the solvers documentation [here](https://mathlab.github.io/PINA/_rst/_code.html#solvers).\n", + "For the last part of the pipeline we need a `Trainer`. We will train the model for **1500 epochs** using the default optimizer parameters. These parameters can be adjusted as needed. For more details, check the solvers documentation [here](https://PINA-org.github.io/PINA/_rst/_code.html#solvers).\n", "\n", "To track metrics during training, we use the **`MetricTracker`** class.\n", "\n", - "> **👉 Want to know more about `Trainer` and how to boost PINA performance? Check out [this tutorial](https://mathlab.github.io/PINA/_rst/tutorials/tutorial11/tutorial.html).**" + "> **👉 Want to know more about `Trainer` and how to boost PINA performance? Check out [this tutorial](https://PINA-org.github.io/PINA/_rst/tutorials/tutorial11/tutorial.html).**" ] }, { @@ -664,7 +664,7 @@ "\n", "4. **...and many more!** — There are countless directions to further explore, from testing on different problems to refining the model architecture!\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/).\n", + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/).\n", "\n", "\n", "### References\n", diff --git a/tutorials/tutorial18/tutorial.ipynb b/tutorials/tutorial18/tutorial.ipynb index ab95e0acb..58ab51e4e 100644 --- a/tutorials/tutorial18/tutorial.ipynb +++ b/tutorials/tutorial18/tutorial.ipynb @@ -8,13 +8,13 @@ "source": [ "# Tutorial: Introduction to Solver classes\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial18/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial18/tutorial.ipynb)\n", "\n", "In this tutorial, we will explore the Solver classes in PINA, that are the core components for optimizing models. Solvers are designed to manage and execute the optimization process, providing the flexibility to work with various types of neural networks and loss functions. We will show how to use this class to select and implement different solvers, such as Supervised or Physics-Informed solvers. By the end of this tutorial, you'll be equipped to easily choose and customize solvers for your own tasks, streamlining the model training process.\n", "\n", "## Introduction to Solvers\n", "\n", - "[`Solvers`](https://mathlab.github.io/PINA/_rst/_code.html#solvers) are versatile objects in PINA designed to manage the training and optimization of machine learning models. They handle key components of the learning process, including:\n", + "[`Solvers`](https://PINA-org.github.io/PINA/_rst/_code.html#solvers) are versatile objects in PINA designed to manage the training and optimization of machine learning models. They handle key components of the learning process, including:\n", "\n", "- Loss function minimization \n", "- Model optimization (optimizer, schedulers)\n", @@ -26,7 +26,7 @@ "\n", "PINA provides three main base solver classes, designed respectively for training a single model, multiple distinct models, or an ensemble of models. These interfaces define the core functionality inherited by all specific solver implementations.\n", "\n", - "### 1. [`SingleModelSolver`](https://mathlab.github.io/PINA/_rst/solver/single_model_solver.html)\n", + "### 1. [`SingleModelSolver`](https://PINA-org.github.io/PINA/_rst/solver/single_model_solver.html)\n", "\n", "This is the base class for solvers that train **a single model**, such as in standard supervised learning or physics-informed training.\n", "\n", @@ -35,13 +35,13 @@ "- `model` – The neural network model.\n", "- `optimizer` – Defaults to `torch.optim.Adam` if not provided.\n", "- `scheduler` – Defaults to `torch.optim.lr_scheduler.ConstantLR`.\n", - "- `weighting` – Optional loss weighting schema., see [here](https://mathlab.github.io/PINA/_rst/_code.html#losses-and-weightings).\n", + "- `weighting` – Optional loss weighting schema., see [here](https://PINA-org.github.io/PINA/_rst/_code.html#losses-and-weightings).\n", "- `loss` - Defaults to `torch.nn.MSELoss`.\n", "- `use_lt` – Whether to use LabelTensors as input.\n", "\n", "---\n", "\n", - "### 2. [`MultiModelSolver`](https://mathlab.github.io/PINA/_rst/solver/multi_model_solver.html)\n", + "### 2. [`MultiModelSolver`](https://PINA-org.github.io/PINA/_rst/solver/multi_model_solver.html)\n", "\n", "This is the base class for solvers involving **multiple models** with distinct behaviours, such as in `SelfAdaptivePhysicsInformedSolver`.\n", "\n", @@ -50,13 +50,13 @@ "- `models` – The models used for training.\n", "- `optimizers` – Defaults to `torch.optim.Adam`.\n", "- `schedulers` – Defaults to `torch.optim.lr_scheduler.ConstantLR`.\n", - "- `weighting` – Optional loss weighting schema, see [here](https://mathlab.github.io/PINA/_rst/_code.html#losses-and-weightings).\n", + "- `weighting` – Optional loss weighting schema, see [here](https://PINA-org.github.io/PINA/_rst/_code.html#losses-and-weightings).\n", "- `loss` - Defaults to `torch.nn.MSELoss`.\n", "- `use_lt` – Whether to use LabelTensors as input.\n", "\n", "---\n", "\n", - "### 3. [`EnsembleSolver`](https://mathlab.github.io/PINA/_rst/solver/ensemble_solver.html)\n", + "### 3. [`EnsembleSolver`](https://PINA-org.github.io/PINA/_rst/solver/ensemble_solver.html)\n", "\n", "This is the base class for solvers that train **an ensemble of models** with the same behaviour, such as in `SupervisedEnsembleSolver`.\n", "\n", @@ -65,7 +65,7 @@ "- `models` – The models used for training.\n", "- `optimizers` – Defaults to `torch.optim.Adam`.\n", "- `schedulers` – Defaults to `torch.optim.lr_scheduler.ConstantLR`.\n", - "- `weighting` – Optional loss weighting schema, see [here](https://mathlab.github.io/PINA/_rst/_code.html#losses-and-weightings).\n", + "- `weighting` – Optional loss weighting schema, see [here](https://PINA-org.github.io/PINA/_rst/_code.html#losses-and-weightings).\n", "- `loss` - Defaults to `torch.nn.MSELoss`.\n", "- `use_lt` – Whether to use LabelTensors as input.\n", "\n", @@ -75,19 +75,19 @@ "\n", "## Structure a Solver with Multiple Inheritance:\n", "\n", - "Thanks to PINA’s modular design, custom solvers can be easily built through **multiple inheritance**. By combining a chosen base solver class with one or more [`Mixins`](https://mathlab.github.io/PINA/_rst/_code.html#mixins), users can define flexible and specialized optimization logic. Each mixin encapsulates an isolated component of the solver behavior, making it possible to assemble reusable building blocks into a fully functional custom solver. Examples include:\n", + "Thanks to PINA’s modular design, custom solvers can be easily built through **multiple inheritance**. By combining a chosen base solver class with one or more [`Mixins`](https://PINA-org.github.io/PINA/_rst/_code.html#mixins), users can define flexible and specialized optimization logic. Each mixin encapsulates an isolated component of the solver behavior, making it possible to assemble reusable building blocks into a fully functional custom solver. Examples include:\n", "\n", "- **`PhysicsInformedSingleModelSolver`**\n", " - Inherits from:\n", "\n", - " - [`PhysicsInformedMixin`](https://mathlab.github.io/PINA/_rst/solver/mixin/physics_informed_mixin.html) → enables gradient computation for validation and test phases\n", - " - [`SingleModelSolver`](https://mathlab.github.io/PINA/_rst/solver/single_model_solver.html) → manages training of a single model\n", + " - [`PhysicsInformedMixin`](https://PINA-org.github.io/PINA/_rst/solver/mixin/physics_informed_mixin.html) → enables gradient computation for validation and test phases\n", + " - [`SingleModelSolver`](https://PINA-org.github.io/PINA/_rst/solver/single_model_solver.html) → manages training of a single model\n", "\n", "- **`AutoregressiveEnsembleSolver`**\n", " - Inherits from: \n", "\n", - " - [`AutoregressiveMixin`](https://mathlab.github.io/PINA/_rst/solver/mixin/autoregressive_mixin.html) → implements autoregressive logic\n", - " - [`EnsembleSolver`](https://mathlab.github.io/PINA/_rst/solver/ensemble_solver.html) → manages training of an ensemble model\n", + " - [`AutoregressiveMixin`](https://PINA-org.github.io/PINA/_rst/solver/mixin/autoregressive_mixin.html) → implements autoregressive logic\n", + " - [`EnsembleSolver`](https://PINA-org.github.io/PINA/_rst/solver/ensemble_solver.html) → manages training of an ensemble model\n", "\n", "This structure promotes **code reuse** and **extensibility**, allowing you to quickly prototype new solver strategies by reusing core training and optimization logic.\n", "\n", @@ -259,7 +259,7 @@ "\n", "3. **...and many more!**: There are countless directions to further explore, try to look at our `solver` for example!\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial19/tutorial.ipynb b/tutorials/tutorial19/tutorial.ipynb index 5ab20f900..54cd9a074 100644 --- a/tutorials/tutorial19/tutorial.ipynb +++ b/tutorials/tutorial19/tutorial.ipynb @@ -8,7 +8,7 @@ "source": [ "# Tutorial: Data structure for SciML: `Tensor`, `LabelTensor`, `Data` and `Graph`\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial19/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial19/tutorial.ipynb)\n", "\n", "In this tutorial, we’ll quickly go through the basics of Data Structures for Scientific Machine Learning, convering:\n", "1. **PyTorch Tensors** / **PINA LabelTensors**\n", @@ -449,13 +449,13 @@ "\n", "Congratulations on completing the tutorials on the **PINA Data Structures**! You now have a solid foundation in using the different data structures within PINA, such as **Tensors**, **Label Tensors**, and **Graphs**. Here are some exciting next steps you can take to continue your learning journey:\n", "\n", - "1. **Deep Dive into Label Tensors**: Check the documentation of [`LabelTensor`](https://mathlab.github.io/PINA/_rst/label_tensor.html) to learn more about the available methods.\n", + "1. **Deep Dive into Label Tensors**: Check the documentation of [`LabelTensor`](https://PINA-org.github.io/PINA/_rst/label_tensor.html) to learn more about the available methods.\n", "\n", - "2. **Working with Graphs in PINA**: In PINA we implement many graph structures, e.g. `KNNGraph`, `RadiusGraph`, .... see [here](https://mathlab.github.io/PINA/_rst/_code.html#graphs-structures) for further details.\n", + "2. **Working with Graphs in PINA**: In PINA we implement many graph structures, e.g. `KNNGraph`, `RadiusGraph`, .... see [here](https://PINA-org.github.io/PINA/_rst/_code.html#graphs-structures) for further details.\n", "\n", "3. **...and many more!**: Consider exploring `LabelTensor` for Physics-Informed Solvers!\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial2/tutorial.ipynb b/tutorials/tutorial2/tutorial.ipynb index 3c37d845c..038073d9c 100644 --- a/tutorials/tutorial2/tutorial.ipynb +++ b/tutorials/tutorial2/tutorial.ipynb @@ -7,7 +7,7 @@ "source": [ "# Tutorial: Enhancing PINNs with Extra Features to solve the Poisson Problem\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial2/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial2/tutorial.ipynb)\n", "\n", "This tutorial presents how to solve with Physics-Informed Neural Networks (PINNs) a 2D Poisson problem with Dirichlet boundary conditions. We will train with standard PINN's training, and with extrafeatures. For more insights on extrafeature learning please read [*An extended physics informed neural network for preliminary analysis of parametric optimal control problems*](https://www.sciencedirect.com/science/article/abs/pii/S0898122123002018).\n", "\n", @@ -66,7 +66,7 @@ "where $D$ is a square domain $[0,1]^2$, and $\\Gamma_i$, with $i=1,...,4$, are the boundaries of the square.\n", "\n", "The Poisson problem is written in **PINA** code as a class. The equations are written as *conditions* that should be satisfied in the corresponding domains. The *solution*\n", - "is the exact solution which will be compared with the predicted one. If interested in how to write problems see [this tutorial](https://mathlab.github.io/PINA/_rst/tutorials/tutorial16/tutorial.html).\n", + "is the exact solution which will be compared with the predicted one. If interested in how to write problems see [this tutorial](https://PINA-org.github.io/PINA/_rst/tutorials/tutorial16/tutorial.html).\n", "\n", "We will directly import the problem from `pina.problem.zoo`, which contains a vast list of PINN problems and more." ] @@ -498,7 +498,7 @@ "\n", "4. **... and many more!.**: There are endless possibilities! Continue exploring and experimenting with new ideas.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial20/tutorial.ipynb b/tutorials/tutorial20/tutorial.ipynb index cb2b79ab5..d6fd46f28 100644 --- a/tutorials/tutorial20/tutorial.ipynb +++ b/tutorials/tutorial20/tutorial.ipynb @@ -8,13 +8,13 @@ "source": [ "# Tutorial: Introductory Tutorial: Supervised Learning with PINA\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial20/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial20/tutorial.ipynb)\n", "\n", "\n", "> ##### ⚠️ ***Before starting:***\n", - "> We assume you are already familiar with the concepts covered in the [Getting started with PINA](https://mathlab.github.io/PINA/_tutorial.html#getting-started-with-pina) tutorials. If not, we strongly recommend reviewing them before exploring this advanced topic.\n", + "> We assume you are already familiar with the concepts covered in the [Getting started with PINA](https://PINA-org.github.io/PINA/_tutorial.html#getting-started-with-pina) tutorials. If not, we strongly recommend reviewing them before exploring this advanced topic.\n", "\n", - "In this tutorial, we will demonstrate a typical use case of **PINA** for Supervised Learning training. We will cover the basics of training a Supervised Solver with PINA, if you want to go further into PINNs look at our dedicated [tutorials](https://mathlab.github.io/PINA/_tutorial.html#supervised-learning) on the topic.\n", + "In this tutorial, we will demonstrate a typical use case of **PINA** for Supervised Learning training. We will cover the basics of training a Supervised Solver with PINA, if you want to go further into PINNs look at our dedicated [tutorials](https://PINA-org.github.io/PINA/_tutorial.html#supervised-learning) on the topic.\n", "\n", "Let's start by importing the useful modules:" ] @@ -151,7 +151,7 @@ "\n", "The problem we will define is a basic `SupervisedProblem`, where the inputs are the coordinates and the outputs are the corresponding Signed Distance Function (SDF) values.\n", "\n", - "> **👉 We have a dedicated [tutorial](https://mathlab.github.io/PINA/tutorial16/tutorial.html) to teach how to build a Problem from scratch — have a look if you're interested!**" + "> **👉 We have a dedicated [tutorial](https://PINA-org.github.io/PINA/tutorial16/tutorial.html) to teach how to build a Problem from scratch — have a look if you're interested!**" ] }, { @@ -344,7 +344,7 @@ "\n", "3. **... and many more!**: The possibilities are vast! Continue experimenting with advanced configurations, solvers, and other features in PINA.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial21/tutorial.ipynb b/tutorials/tutorial21/tutorial.ipynb index ee5832878..d2b61646b 100644 --- a/tutorials/tutorial21/tutorial.ipynb +++ b/tutorials/tutorial21/tutorial.ipynb @@ -8,13 +8,13 @@ "source": [ "# Tutorial: Introductory Tutorial: Neural Operator Learning with PINA\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial21/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial21/tutorial.ipynb)\n", "\n", "\n", "> ##### ⚠️ ***Before starting:***\n", - "> We assume you are already familiar with the concepts covered in the [Getting started with PINA](https://mathlab.github.io/PINA/_tutorial.html#getting-started-with-pina) tutorials. If not, we strongly recommend reviewing them before exploring this advanced topic.\n", + "> We assume you are already familiar with the concepts covered in the [Getting started with PINA](https://PINA-org.github.io/PINA/_tutorial.html#getting-started-with-pina) tutorials. If not, we strongly recommend reviewing them before exploring this advanced topic.\n", "\n", - "In this tutorial, we will demonstrate a typical use case of **PINA** for Neural Operator learning. We will cover the basics of training a Neural Operator with PINA, if you want to go further into the topic look at our dedicated [tutorials](https://mathlab.github.io/PINA/_tutorial.html#neural-operator-learning) on the topic.\n", + "In this tutorial, we will demonstrate a typical use case of **PINA** for Neural Operator learning. We will cover the basics of training a Neural Operator with PINA, if you want to go further into the topic look at our dedicated [tutorials](https://PINA-org.github.io/PINA/_tutorial.html#neural-operator-learning) on the topic.\n", "\n", "Let's start by importing the useful modules:" ] @@ -153,7 +153,7 @@ "At their core, **Neural Operators** transform an input function $a$ into an output function $u$. The general structure of a Neural Operator consists of three key components:\n", "\n", "

\n", - " \"Neural\n", + " \"Neural\n", "

\n", "\n", "1. **Encoder**: The encoder maps the input into a specific embedding space.\n", @@ -169,11 +169,11 @@ "\n", "- **Fourier Neural Operator (FNO)**: \n", " The **Fourier Neural Operator** utilizes the **Fourier transform** in the processor to perform global convolutions. This enables the operator to capture long-range dependencies efficiently. FNOs are particularly useful for problems with periodic data or problems where global patterns and interactions are important. \n", - " ➤ [Learn more about FNO](https://mathlab.github.io/PINA/_rst/model/fourier_neural_operator.html).\n", + " ➤ [Learn more about FNO](https://PINA-org.github.io/PINA/_rst/model/fourier_neural_operator.html).\n", "\n", "- **Graph Neural Operator (GNO)**: \n", " The **Graph Neural Operator** leverages **Graph Neural Networks (GNNs)** to exchange information between nodes, enabling the operator to perform convolutions on unstructured domains, such as graphs or meshes. GNOs are especially useful for problems that naturally involve irregular data, such as graph-based datasets or data on non-Euclidean spaces. \n", - " ➤ [Learn more about GNO](https://mathlab.github.io/PINA/_rst/model/graph_neural_operator.html).\n", + " ➤ [Learn more about GNO](https://PINA-org.github.io/PINA/_rst/model/graph_neural_operator.html).\n", "\n", "- **Deep Operator Network (DeepONet)**: \n", " **DeepONet** is a variant of Neural Operators designed to solve operator equations by learning mappings between input and output functions. Unlike other Neural Operators, **DeepONet** does not use the typical encoder-processor-decoder structure. Instead, it uses two distinct neural networks:\n", @@ -182,7 +182,7 @@ " 2. **Trunk Network**: Takes the **spatial locations** (e.g., $x$) and maps them to the output space.\n", " \n", " The output of **DeepONet** is the combination of these two networks' outputs, which together provide the mapping from the input function to the output function. \n", - " ➤ [Learn more about DeepONet](https://mathlab.github.io/PINA/_rst/model/deeponet.html).\n", + " ➤ [Learn more about DeepONet](https://PINA-org.github.io/PINA/_rst/model/deeponet.html).\n", "\n", "In this tutorial we will focus on Neural Operator which follow the Encoder - Processor - Decoder structure, which we call *Kernel* Neural Operator. Implementing kernel neural Operators in PINA is very simple, you just need to use the `KernelNeuralOperator` API.\n", "\n", @@ -195,7 +195,7 @@ "\n", "3. `projection_operator`: a `torch.nn.Module` representing the hidden representation to the output function.\n", "\n", - "To construct the kernel, you can use the Neural Operator Blocks available in PINA (see [here](https://mathlab.github.io/PINA/_rst/_code.html#blocks)) or implement you own one! Let's build a simple FNO using the `FourierBlock1D`. In particular we will:\n", + "To construct the kernel, you can use the Neural Operator Blocks available in PINA (see [here](https://PINA-org.github.io/PINA/_rst/_code.html#blocks)) or implement you own one! Let's build a simple FNO using the `FourierBlock1D`. In particular we will:\n", "\n", "1. Define the encoder, a simple linear layer mapping the input dimension to the hidden dimension\n", "2. Define the decoder, two linear layers mapping the hidden dimension to 128 and back to the input dimension\n", @@ -272,9 +272,9 @@ "source": [ "Done! Let's now solve the Neural Operator problem. The problem we will define is a basic `SupervisedProblem`, and we will use the `SupervisedSingleModelSolver` to train the Neural Operator.\n", "\n", - "> **👉 We have a dedicated [tutorial](https://mathlab.github.io/PINA/tutorial16/tutorial.html) to teach how to build a Problem from scratch — have a look if you're interested!**\n", + "> **👉 We have a dedicated [tutorial](https://PINA-org.github.io/PINA/tutorial16/tutorial.html) to teach how to build a Problem from scratch — have a look if you're interested!**\n", "\n", - "> **👉 We have a dedicated [tutorial](http://mathlab.github.io/PINA/_rst/tutorials/tutorial18/tutorial.html) for an overview of Solvers in PINA — have a look if you're interested!**" + "> **👉 We have a dedicated [tutorial](http://PINA-org.github.io/PINA/_rst/tutorials/tutorial18/tutorial.html) for an overview of Solvers in PINA — have a look if you're interested!**" ] }, { @@ -355,7 +355,7 @@ "\n", "3. **...and many more!** — The possibilities are vast! Continue experimenting with advanced configurations, solvers, and features in PINA. For example, consider incorporating physics-informed terms during training to enhance model generalization.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial22/tutorial.ipynb b/tutorials/tutorial22/tutorial.ipynb index 8bf8821c0..64dc08d18 100644 --- a/tutorials/tutorial22/tutorial.ipynb +++ b/tutorials/tutorial22/tutorial.ipynb @@ -8,11 +8,11 @@ "source": [ "# Tutorial: Reduced Order Model with Graph Neural Networks\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial22/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial22/tutorial.ipynb)\n", "\n", "\n", "> ##### ⚠️ ***Before starting:***\n", - "> We assume you are already familiar with the concepts covered in the [Data Structure for SciML](https://mathlab.github.io/PINA/tutorial19/tutorial.html) tutorial. If not, we strongly recommend reviewing them before exploring this advanced topic.\n", + "> We assume you are already familiar with the concepts covered in the [Data Structure for SciML](https://PINA-org.github.io/PINA/tutorial19/tutorial.html) tutorial. If not, we strongly recommend reviewing them before exploring this advanced topic.\n", "\n", "In this tutorial, we use **PINA** to construct a graph-based reduced-order model for a parametrized partial differential equation. The workflow is largely inspired by [*A graph convolutional autoencoder approach to model order reduction for parametrized PDEs*](https://www.sciencedirect.com/science/article/pii/S0021999124000111).\n", "\n", @@ -42,7 +42,7 @@ " IN_COLAB = False\n", "if IN_COLAB:\n", " !pip install \"pina-mathlab[tutorial]\"\n", - " !wget \"https://github.com/mathLab/PINA/raw/refs/heads/master/tutorials/tutorial22/holed_poisson.pt\" -O \"holed_poisson.pt\"\n", + " !wget \"https://github.com/PINA-org/PINA/raw/refs/heads/master/tutorials/tutorial22/holed_poisson.pt\" -O \"holed_poisson.pt\"\n", "\n", "import torch\n", "from torch_geometric.nn import GMMConv\n", @@ -172,7 +172,7 @@ "Convolutional neural networks are naturally suited to regular grids, but the domains in this dataset are represented by unstructured meshes. A graph representation removes the need for a regular grid: mesh points become nodes, and mesh connectivity becomes the edge structure. This makes a **graph neural network (GNN)** a suitable choice for processing the solution fields.\n", "\n", "

\n", - " \"GCA-ROM\n", + " \"GCA-ROM\n", "

\n", "\n", "The reduced-order model has three components:\n", @@ -318,7 +318,7 @@ "\n", "We now train the autoencoder with PINA's supervised-learning workflow.\n", "\n", - "First, we define a [`SupervisedProblem`](https://mathlab.github.io/PINA/_rst/problem/zoo/supervised_problem.html#module-pina.problem.zoo.supervised_problem):\n", + "First, we define a [`SupervisedProblem`](https://PINA-org.github.io/PINA/_rst/problem/zoo/supervised_problem.html#module-pina.problem.zoo.supervised_problem):\n", "\n", "- **input:** graph objects containing the solution fields and mesh information;\n", "- **target:** the original node-wise solution values that the autoencoder must reconstruct.\n", @@ -683,7 +683,7 @@ "\n", "3. **...and many more!** — The possibilities are vast! Continue experimenting with advanced configurations, solvers, and features in PINA.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial23/tutorial.ipynb b/tutorials/tutorial23/tutorial.ipynb index 3f37e94cb..9e8273374 100644 --- a/tutorials/tutorial23/tutorial.ipynb +++ b/tutorials/tutorial23/tutorial.ipynb @@ -7,11 +7,11 @@ "source": [ "# Tutorial: Data-driven System Identification with SINDy\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial23/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial23/tutorial.ipynb)\n", "\n", "\n", "> ##### ⚠️ ***Before starting:***\n", - "> We assume you are already familiar with the concepts covered in the [Getting started with PINA](https://mathlab.github.io/PINA/_tutorial.html#getting-started-with-pina) tutorial. If not, we strongly recommend reviewing them before exploring this advanced topic.\n", + "> We assume you are already familiar with the concepts covered in the [Getting started with PINA](https://PINA-org.github.io/PINA/_tutorial.html#getting-started-with-pina) tutorial. If not, we strongly recommend reviewing them before exploring this advanced topic.\n", "\n", "In this tutorial, we will demonstrate a typical use case of **PINA** for Data-driven system identification using SINDy. The tutorial is largely inspired by the paper [Discovering governing equations from data by sparse identification of nonlinear dynamical systems](dx.doi.org/10.1073/pnas.1517384113).\n", "\n", @@ -249,7 +249,7 @@ "source": [ "## Training with PINA\n", "We are now ready to train our model! We can use **PINA** to train the model, following the workflow from previous tutorials.\n", - "First, we need to define the problem. In this case, we will use the [`SupervisedProblem`](https://mathlab.github.io/PINA/_rst/problem/zoo/supervised_problem.html#module-pina.problem.zoo.supervised_problem), which expects: \n", + "First, we need to define the problem. In this case, we will use the [`SupervisedProblem`](https://PINA-org.github.io/PINA/_rst/problem/zoo/supervised_problem.html#module-pina.problem.zoo.supervised_problem), which expects: \n", "\n", "- **Input**: the state variables tensor $\\boldsymbol{X}$ containing all the collected snapshots. \n", "- **Output**: the corresponding time derivatives $\\dot{\\boldsymbol{X}}$." @@ -442,7 +442,7 @@ "\n", "3. **...and many more!** — The possibilities are vast! Continue experimenting with advanced configurations, solvers, and features in PINA.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial24/tutorial.ipynb b/tutorials/tutorial24/tutorial.ipynb index f172998aa..b5cbddc13 100644 --- a/tutorials/tutorial24/tutorial.ipynb +++ b/tutorials/tutorial24/tutorial.ipynb @@ -7,11 +7,11 @@ "source": [ "# Tutorial: Advection Equation with data driven DeepONet\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial24/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial24/tutorial.ipynb)\n", "\n", "\n", "> ##### ⚠️ ***Before starting:***\n", - "> We assume you are already familiar with the concepts covered in the [Getting started with PINA](https://mathlab.github.io/PINA/_tutorial.html#getting-started-with-pina) tutorials. If not, we strongly recommend reviewing them before exploring this advanced topic.\n", + "> We assume you are already familiar with the concepts covered in the [Getting started with PINA](https://PINA-org.github.io/PINA/_tutorial.html#getting-started-with-pina) tutorials. If not, we strongly recommend reviewing them before exploring this advanced topic.\n", "\n", "In this tutorial, we demonstrate how to solve the advection operator learning problem using `DeepONet`. We follow the original formulation of Lu *et al.* in [*DeepONet: Learning nonlinear operators for identifying differential equations based on the universal approximation theorem of operator*](https://arxiv.org/abs/1910.03193).\n", "\n", @@ -35,10 +35,10 @@ " !pip install \"pina-mathlab[tutorial]\"\n", " # get the data\n", " !mkdir \"data\"\n", - " !wget \"https://github.com/mathLab/PINA/raw/refs/heads/master/tutorials/tutorial24/data/advection_input_testing.pt\" -O \"data/advection_input_testing.pt\"\n", - " !wget \"https://github.com/mathLab/PINA/raw/refs/heads/master/tutorials/tutorial24/data/advection_input_training.pt\" -O \"data/advection_input_training.pt\"\n", - " !wget \"https://github.com/mathLab/PINA/raw/refs/heads/master/tutorials/tutorial24/data/advection_output_testing.pt\" -O \"data/advection_output_testing.pt\"\n", - " !wget \"https://github.com/mathLab/PINA/raw/refs/heads/master/tutorials/tutorial24/data/advection_output_training.pt\" -O \"data/advection_output_training.pt\"\n", + " !wget \"https://github.com/PINA-org/PINA/raw/refs/heads/master/tutorials/tutorial24/data/advection_input_testing.pt\" -O \"data/advection_input_testing.pt\"\n", + " !wget \"https://github.com/PINA-org/PINA/raw/refs/heads/master/tutorials/tutorial24/data/advection_input_training.pt\" -O \"data/advection_input_training.pt\"\n", + " !wget \"https://github.com/PINA-org/PINA/raw/refs/heads/master/tutorials/tutorial24/data/advection_output_testing.pt\" -O \"data/advection_output_testing.pt\"\n", + " !wget \"https://github.com/PINA-org/PINA/raw/refs/heads/master/tutorials/tutorial24/data/advection_output_training.pt\" -O \"data/advection_output_training.pt\"\n", "\n", "import matplotlib.pyplot as plt\n", "import torch\n", @@ -156,7 +156,7 @@ "The standard `DeepONet` architecture consists of two subnetworks: a **branch** network and a **trunk** network (see figure below).\n", "\n", "
\n", - "\"image\n", + "\"image\n", "
\n", "
\n", "Image source: Moya & Lin (2022)\n", @@ -387,7 +387,7 @@ "\n", "5. **...and much more!**: From adding noise robustness to testing on real scientific datasets, the space of possibilities is wide open.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial3/tutorial.ipynb b/tutorials/tutorial3/tutorial.ipynb index d57b0741e..4322895d2 100644 --- a/tutorials/tutorial3/tutorial.ipynb +++ b/tutorials/tutorial3/tutorial.ipynb @@ -7,7 +7,7 @@ "source": [ "# Tutorial: Applying Hard Constraints in PINNs to solve the Wave Problem\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial3/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial3/tutorial.ipynb)\n", "\n", "In this tutorial, we will present how to solve the wave equation using **hard constraint Physics-Informed Neural Networks (PINNs)**. To achieve this, we will build a custom `torch` model and pass it to the **PINN solver**.\n", "\n", @@ -446,7 +446,7 @@ "\n", "4. **...and many more!**: The possibilities are endless! Keep experimenting and pushing the boundaries.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial4/tutorial.ipynb b/tutorials/tutorial4/tutorial.ipynb index 4e7c2fa33..bb041ec2f 100644 --- a/tutorials/tutorial4/tutorial.ipynb +++ b/tutorials/tutorial4/tutorial.ipynb @@ -6,7 +6,7 @@ "metadata": {}, "source": [ "# Tutorial: Unstructured Convolutional Autoencoders with Continuous Convolution\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial4/tutorial.ipynb)" + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial4/tutorial.ipynb)" ] }, { @@ -877,7 +877,7 @@ "\n", "4. **...and many more!**: There are endless possibilities, from improving model architecture to testing with more complex datasets.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial5/tutorial.ipynb b/tutorials/tutorial5/tutorial.ipynb index 30a9461fd..43078a549 100644 --- a/tutorials/tutorial5/tutorial.ipynb +++ b/tutorials/tutorial5/tutorial.ipynb @@ -7,7 +7,7 @@ "source": [ "# Tutorial: Modeling 2D Darcy Flow with the Fourier Neural Operator\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial5/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial5/tutorial.ipynb)\n", "\n", "In this tutorial, we are going to solve the **Darcy flow problem** in two dimensions, as presented in the paper [*Fourier Neural Operator for Parametric Partial Differential Equations*](https://openreview.net/pdf?id=c8P9NQVtmnO).\n", "\n", @@ -37,7 +37,7 @@ " !pip install \"pina-mathlab[tutorial]\"\n", " !pip install scipy\n", " # get the data\n", - " !wget https://github.com/mathLab/PINA/raw/refs/heads/master/tutorials/tutorial5/Data_Darcy.mat\n", + " !wget https://github.com/PINA-org/PINA/raw/refs/heads/master/tutorials/tutorial5/Data_Darcy.mat\n", "\n", "import torch\n", "import matplotlib.pyplot as plt\n", @@ -346,7 +346,7 @@ "\n", "3. **...and many more!**: There are countless directions to further explore. For instance, you could try to add physics informed learning!\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial6/tutorial.ipynb b/tutorials/tutorial6/tutorial.ipynb index d14c479d8..b338c2e79 100644 --- a/tutorials/tutorial6/tutorial.ipynb +++ b/tutorials/tutorial6/tutorial.ipynb @@ -6,7 +6,7 @@ "source": [ "# Tutorial: Building domains with PINA's `BaseDomain` class\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial6/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial6/tutorial.ipynb)\n", "\n", "In this tutorial, we explore how to use and visualize PINA’s built-in geometric domains and how to construct custom ones. We will cover:\n", "- Creating domains using `CartesianDomain`, `EllipsoidDomain`, and `SimplexDomain`\n", @@ -505,7 +505,7 @@ "\n", "3. **...and many more!**: Implement new geometries using DomainInterface and push PINA’s capabilities further.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial7/tutorial.ipynb b/tutorials/tutorial7/tutorial.ipynb index c8ad80c24..b1a3ceb42 100644 --- a/tutorials/tutorial7/tutorial.ipynb +++ b/tutorials/tutorial7/tutorial.ipynb @@ -7,7 +7,7 @@ "source": [ "# Tutorial: Inverse Problem Solving with Physics-Informed Neural Network\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial7/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial7/tutorial.ipynb)\n", "\n", "## Introduction to the Inverse Problem\n", "\n", @@ -53,8 +53,8 @@ " !pip install \"pina-mathlab[tutorial]\"\n", " # get the data\n", " !mkdir \"data\"\n", - " !wget \"https://github.com/mathLab/PINA/raw/refs/heads/master/tutorials/tutorial7/data/pinn_solution_0.5_0.5\" -O \"data/pinn_solution_0.5_0.5\"\n", - " !wget \"https://github.com/mathLab/PINA/raw/refs/heads/master/tutorials/tutorial7/data/pts_0.5_0.5\" -O \"data/pts_0.5_0.5\"\n", + " !wget \"https://github.com/PINA-org/PINA/raw/refs/heads/master/tutorials/tutorial7/data/pinn_solution_0.5_0.5\" -O \"data/pinn_solution_0.5_0.5\"\n", + " !wget \"https://github.com/PINA-org/PINA/raw/refs/heads/master/tutorials/tutorial7/data/pts_0.5_0.5\" -O \"data/pts_0.5_0.5\"\n", "\n", "import matplotlib.pyplot as plt\n", "import torch\n", @@ -201,7 +201,7 @@ "id": "6b264569-57b3-458d-bb69-8e94fe89017d", "metadata": {}, "source": [ - "Next, we define the neural network model that will be used for solving the inverse problem. In this case, we use a simple FeedForeard model, but you could build one that imposes *hard constraints* on the boundary conditions, similar to the approach used in the [Wave tutorial](https://mathlab.github.io/PINA/tutorial3/tutorial.html) to have better performances!" + "Next, we define the neural network model that will be used for solving the inverse problem. In this case, we use a simple FeedForeard model, but you could build one that imposes *hard constraints* on the boundary conditions, similar to the approach used in the [Wave tutorial](https://PINA-org.github.io/PINA/tutorial3/tutorial.html) to have better performances!" ] }, { @@ -358,7 +358,7 @@ "\n", "3. **...and many more!**: The possibilities are endless, from integrating additional physical constraints to testing on real-world datasets.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ], diff --git a/tutorials/tutorial8/tutorial.ipynb b/tutorials/tutorial8/tutorial.ipynb index 1d2f9dc3e..e41ce9c34 100644 --- a/tutorials/tutorial8/tutorial.ipynb +++ b/tutorials/tutorial8/tutorial.ipynb @@ -7,7 +7,7 @@ "source": [ "# Tutorial: Reduced Order Modeling with POD-RBF and POD-NN Approaches for Fluid Dynamics\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial8/tutorial.ipynb)" + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial8/tutorial.ipynb)" ] }, { @@ -409,7 +409,7 @@ "\n", "5. **...and many more!**: The potential applications of reduced order models are vast, ranging from material science simulations to real-time predictions in engineering applications.\n", "\n", - "For more information and advanced tutorials, refer to the [PINA Documentation](https://mathlab.github.io/PINA/).\n", + "For more information and advanced tutorials, refer to the [PINA Documentation](https://PINA-org.github.io/PINA/).\n", "\n", "### References\n", "1. Rozza G., Stabile G., Ballarin F. (2022). Advanced Reduced Order Methods and Applications in Computational Fluid Dynamics, Society for Industrial and Applied Mathematics. \n", diff --git a/tutorials/tutorial9/tutorial.ipynb b/tutorials/tutorial9/tutorial.ipynb index a23ed1abb..f1a548f0f 100644 --- a/tutorials/tutorial9/tutorial.ipynb +++ b/tutorials/tutorial9/tutorial.ipynb @@ -6,7 +6,7 @@ "source": [ "# Tutorial: Applying Periodic Boundary Conditions in PINNs to solve the Helmholtz Problem\n", "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial9/tutorial.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PINA-org/PINA/blob/master/tutorials/tutorial9/tutorial.ipynb)\n", "\n", "This tutorial demonstrates how to solve a one-dimensional Helmholtz equation with periodic boundary conditions (PBC) using Physics-Informed Neural Networks (PINNs). \n", "We will use standard Physics-Informed training, augmented with a periodic input expansion as introduced in [*An Expert’s Guide to Training Physics-Informed Neural Networks*](https://arxiv.org/abs/2308.08468).\n", @@ -301,7 +301,7 @@ "\n", "4. **...and many more!**: Extend to higher dimensions, test on other PDEs, or even develop custom embeddings tailored to your problem.\n", "\n", - "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." + "For more resources and tutorials, check out the [PINA Documentation](https://PINA-org.github.io/PINA/)." ] } ],