diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 000000000..2cbbcf345 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1,35 @@ +# CODEOWNERS file for PINA + +# The default owners for everything in the repo +# (Pull requests touching any file in "/" will require review from at least one of these) +* @mathLab/pina-developers +pina/ @mathLab/pina-developers +readme/ @mathLab/pina-developers +tests/ @mathLab/pina-developers +tutorials/ @mathLab/pina-developers +pyproject.toml @mathLab/pina-developers @ndem0 + +# Owners for documentation +docs/ @mathLab/pina-developers @dario-coscia + +# Owners for JOSS +joss/ @ndem0 @annaivagnes @dario-coscia + +# Owners for project-wide config (GitHub workflows, formatting, etc.) +.github/ @ndem0 @dario-coscia +.gitattributes @ndem0 @dario-coscia +.gitignore @ndem0 @dario-coscia + +# Security & policy files +CITATION.cff @FilippoOlivo @GiovanniCanali @ndem0 @dario-coscia +CONTRIBUTING.md @FilippoOlivo @GiovanniCanali @ndem0 @dario-coscia +LICENSE.rst @FilippoOlivo @GiovanniCanali @ndem0 @dario-coscia +SECURITY.md @FilippoOlivo @GiovanniCanali @ndem0 @dario-coscia +CODE_OF_CONDUCT.md @FilippoOlivo @GiovanniCanali @ndem0 @dario-coscia +MAINTAINERS.md @FilippoOlivo @GiovanniCanali @ndem0 @dario-coscia +ANTITRUST.md @FilippoOlivo @GiovanniCanali @ndem0 @dario-coscia +CHARTER.md @FilippoOlivo @GiovanniCanali @ndem0 @dario-coscia +GOVERNANCE.md @FilippoOlivo @GiovanniCanali @ndem0 @dario-coscia +STEERING-COMMITTEE.md @FilippoOlivo @GiovanniCanali @ndem0 @dario-coscia +TRADEMARKS.md @FilippoOlivo @GiovanniCanali @ndem0 @dario-coscia +utils @FilippoOlivo @GiovanniCanali @ndem0 @dario-coscia diff --git a/ANTITRUST.md b/ANTITRUST.md new file mode 100644 index 000000000..f819d59b8 --- /dev/null +++ b/ANTITRUST.md @@ -0,0 +1,8 @@ +# Antitrust Policy + +Participants acknowledge that they may compete with other participants in various lines of business and that it is therefore imperative that they and their respective representatives act in a manner that does not violate any applicable antitrust laws, competition laws, or associated regulations. This Policy does not restrict any participant from engaging in other similar projects. Each participant may design, develop, manufacture, acquire or market competitive deliverables, products, and services, and conduct its business, in whatever way it chooses. No participant is obligated to announce or market any products or services. Without limiting the generality of the foregoing, participants agree not to have any discussion relating to any product pricing, methods or channels of product distribution, contracts with third-parties, division or allocation of markets, geographic territories, or customers, or any other topic that relates in any way to limiting or lessening fair competition. + +--- +## Attribution +This file is adapted from the [Minimum Viable Governance][https://github.com/github/MVG], +homepage, Licensed under the [CC-BY 4.0 License](https://creativecommons.org/licenses/by/4.0/). \ No newline at end of file diff --git a/CHARTER.md b/CHARTER.md new file mode 100644 index 000000000..6a03b9605 --- /dev/null +++ b/CHARTER.md @@ -0,0 +1,71 @@ +# Charter for the PINA Organization + +This is the organizational charter for the PINA Organization. In this Charter and related documents, “PINA Organization” means the entity designated in this Charter as the governing body of the PINA project. At the time of writing, this is the PINA Steering Committee. If governance changes in the future, references to “PINA Organization” automatically refer to the successor entity named here without rewriting other policies. By adding their name to the [Steering Committee.md file](https://github.com/mathLab/PINA/blob/master/STEERING-COMMITTEE.md), Steering Committee members agree as follows. + +## 1. Mission + +PINA mission is to advance open, accessible, and reliable computational tools that bridge mathematics, data, and real-world applications using Machine Learning. We strive to: + +Empower researchers, educators, and practitioners with robust, transparent, and well-documented frameworks for scientific discovery. + +Accelerate innovation by integrating classical mathematical methods with modern computational machine learning-based techniques. + +Promote collaboration and openness by maintaining a community-driven platform built on principles of reproducibility, interoperability, and long-term sustainability. + +By pursuing these goals, the Organization aims to be a cornerstone resource in computational mathematics, supporting both theoretical advances and impactful applications across disciplines. + + +## 2. Steering Committee + +**2.1 Purpose**. The Steering Committee will be responsible for all technical oversight, project approval and oversight, policy oversight, and trademark management. + +**2.2 Composition**. The Steering Committee voting members are listed in the [STEERING-COMMITEE.md](https://github.com/mathLab/PINA/blob/master/STEERING-COMMITTEE.md) file in the repository. +Voting members may be added or removed by no less than 75% affirmative vote of the Steering Committee. +The Steering Committee will appoint a Chair responsible for organizing Steering Committee activity. + +## 3. Voting + +**3.1. Decision Making**. The Steering Committee will strive for all decisions to be made by consensus. While explicit agreement of the entire Steering Committee is preferred, it is not required for consensus. Rather, the Steering Committee will determine consensus based on their good faith consideration of a number of factors, including the dominant view of the Steering Committee and nature of support and objections. The Steering Committee will document evidence of consensus in accordance with these requirements. If consensus cannot be reached, the Steering Committee will make the decision by a vote. + +**3.2. Voting**. The Steering Committee Chair will call a vote with reasonable notice to the Steering Committee, setting out a discussion period and a separate voting period. Any discussion may be conducted in person or electronically by text, voice, or video. The discussion will be open to the public. In any vote, each voting representative will have one vote. Except as specifically noted elsewhere in this Charter, decisions by vote require a simple majority vote of all voting members. + +## 4. Termination of Membership + +In addition to the method set out in section 2.2, the membership of a Steering Committee member will terminate if any of the following occur: + +**4.1 Resignation**. Written notice of resignation to the Steering Committee. + +**4.2 Unreachable Member**. If a member is unresponsive at its listed handle for more than three months the Steering Committee may vote to remove the member. + +## 5. Trademarks + +Any names, trademarks, service marks, logos, mascots, or similar indicators of source or origin and the goodwill associated with them arising out of the PINA's activities or PINA projects' activities (the "Marks"), are controlled by the PINA Organization. PINA Marks may be only used in accordance with the [trademark policy](https://github.com/mathLab/PINA/blob/master/TRADEMARKS.md). + +## 6. Antitrust Policy + +The Steering Committee is bound by the [antitrust policy](https://github.com/mathLab/PINA/blob/master/ANTITRUST.md). + +## 7. No Confidentiality + +Information disclosed in connection with any of the PINA's activities, including but not limited to meetings, contributions, and submissions, is not confidential, regardless of any markings or statements to the contrary. + +## 8. Project Criteria + +In order to be eligible to be a PINA project, a project must: + +* Be approved by the Steering Committee. +* Agree to follow the guidance and direction of the Steering Committee. +* Use only the following outbound licenses or agreements unless otherwise approved: + - For code, a license on the Open Source Initiative's list of [Popular Licenses](https://opensource.org/licenses). + - For data, a license on the Open Knowledge Foundation's list of [Recommended Conformant Licenses](http://opendefinition.org/licenses/). + - For specifications, a community developed and maintained specification agreement, such the [Open Web Foundation Agreements](https://www.openwebfoundation.org/the-agreements) or [Community Specification Agreement](https://github.com/CommunitySpecification/1.0). +* Include and adhere to the PINA's policies, including the [trademark policy](https://github.com/mathLab/PINA/blob/master/TRADEMARKS.md), the [antitrust policy](https://github.com/mathLab/PINA/blob/master/ANTITRUST.md), and the [code of conduct](https://github.com/mathLab/PINA/blob/master/CODE_OF_CONDUCT.md). + +## 9. Amendments + +Amendments to this charter, the [antitrust policy](https://github.com/mathLab/PINA/blob/master/ANTITRUST.md), the [trademark policy](https://github.com/mathLab/PINA/blob/master/TRADEMARKS.md), or the [code of conduct](https://github.com/mathLab/PINA/blob/master/CODE_OF_CONDUCT.md) may only be made with at least a 75% affirmative vote of the Steering Committee. + +--- +## Attribution +This file is adapted from the [Minimum Viable Governance][https://github.com/github/MVG], +homepage, Licensed under the [CC-BY 4.0 License](https://creativecommons.org/licenses/by/4.0/). diff --git a/GOVERNANCE.md b/GOVERNANCE.md new file mode 100644 index 000000000..63ffc753a --- /dev/null +++ b/GOVERNANCE.md @@ -0,0 +1,48 @@ +# Governance Policy + +This document provides the governance policy for the PINA. Maintainers agree to this policy and to abide by all PINA polices, including the [code of conduct](https://github.com/mathLab/PINA/blob/master/CODE_OF_CONDUCT.md), [trademark policy](https://github.com/mathLab/PINA/blob/master/TRADEMARKS.md), and [antitrust policy](https://github.com/mathLab/PINA/blob/master/ANTITRUST.md) by adding their name to the [maintainers.md file](https://github.com/mathLab/PINA/blob/master/MAINTAINERS.md). + +## 1. Roles. + +This project may include the following roles. Additional roles may be adopted and documented by the Project. + +**1.1. PINA Organization**. The PINA Organization provides strategic and policy stewardship, manages project assets (including Marks as defined in the trademark policy), resolves escalations, and approves changes to governance and charter documents. + +**1.2. Maintainers**. Maintainers are responsible for organizing activities around developing, maintaining, and updating the project. Maintainers are also responsible for determining consensus. Maintainers may be added or removed with the approval of the current Maintainers. + +**1.3. Contributors**. Contributors are those who make contributions to the project (e.g., code, documentation, issues, reviews). + +## 2. Decisions. + +**2.1. Consensus-Based Decision Making**. The project seeks consensus of the Maintainers. While explicit agreement of all Maintainers is preferred, it is not required. Maintainers will determine consensus based on good-faith consideration of factors including the dominant view of Contributors and the nature of support and objections. Evidence of consensus should be documented (e.g., via issues/PRs, meeting notes). + +**2.2. Appeal Process**. Project decisions may be appealed by opening an issue. Maintainers will consider the appeal in good faith and respond in writing within a reasonable time. If the Maintainers deny the appeal, it may be escalated to the PINA Organization, which will also respond in writing within a reasonable time. + +## 3. How We Work. + +**3.1. Openness**. Participation is open to anyone who is directly and materially affected by the activity in question. There shall be no undue financial barriers to participation. + +**3.2. Balance**. The development process should balance the interests of Contributors and other stakeholders. Contributors from diverse interest categories shall be sought with the objective of achieving balance. + +**3.3. Coordination and Harmonization**. Good faith efforts shall be made to resolve potential conflicts or incompatibility between releases in this Project. + +**3.4. Consideration of Views and Objections**. Prompt consideration shall be given to the written views and objections of all Contributors. + +**3.5. Written procedures**. This governance document and other materials documenting this project's development process shall be available to any interested person. + +## 4. No Confidentiality. + +Information disclosed in connection with any Project activity, including but not limited to meetings, contributions, and submissions, is not confidential, regardless of any markings or statements to the contrary. + +## 5. Trademarks. + +Any names, trademarks, logos, or goodwill developed by and associated with the project (the “Marks”) are controlled by the PINA Organization. Maintainers and Contributors may only use these Marks in accordance with the project’s (trademark policy)[]. + +## 6. Amendments. + +Amendments to this governance policy may be made by affirmative vote of 2/3 of all Maintainers, with approval by the Organization's Steering Committee. + +--- +## Attribution +This file is adapted from the [Minimum Viable Governance][https://github.com/github/MVG], +homepage, Licensed under the [CC-BY 4.0 License](https://creativecommons.org/licenses/by/4.0/). diff --git a/MAINTAINERS.md b/MAINTAINERS.md new file mode 100644 index 000000000..143706f80 --- /dev/null +++ b/MAINTAINERS.md @@ -0,0 +1,22 @@ +# Maintainers List + +# Maintainers + +This document lists the Maintainers of the Project. Maintainers may be added once approved by the existing maintainers as described in the [Governance document](https://github.com/mathLab/PINA/blob/master/GOVERNANCE.md). By adding your name to this list you are agreeing to abide by the Project governance documents and to abide by all of the Organization's polices, including the [code of conduct](https://github.com/mathLab/PINA/blob/master/CODE_OF_CONDUCT.md), [trademark policy](https://github.com/mathLab/PINA/blob/master/TRADEMARKS.md), and [antitrust policy](https://github.com/mathLab/PINA/blob/master/ANTITRUST.md). If you are participating because of your affiliation with another organization (designated below), you represent that you have the authority to bind that organization to these policies. + + +| **GithubID** | **Email Address** | **Organization** | +| ------------ | ------------------------ | ---------------------- | +| @GiovanniCanali | giovanni.canali98@yahoo.it | SISSA | +| @dario-coscia | dariocos99@gmail.com | SISSA | +| @ndem0 | demo.nicola@gmail.com | SISSA - FAST COMPUTING SRL | +| @AleDinve | gdinvern@sissa.it | SISSA | +| @annaivagnes | aivagnes@sissa.it | SISSA | +| @FilippoOlivo | filippo@filippoolivo.com | SISSA - FAST COMPUTING SRL | +| @guglielmopadula | gpadula@sissa.it | SISSA | +| @fpichi | fpichi@sissa.it | SISSA | + +--- +## Attribution +This file is adapted from the [Minimum Viable Governance][https://github.com/github/MVG], +homepage, Licensed under the [CC-BY 4.0 License](https://creativecommons.org/licenses/by/4.0/). diff --git a/STEERING-COMMITTEE.md b/STEERING-COMMITTEE.md new file mode 100644 index 000000000..b97c3a0b9 --- /dev/null +++ b/STEERING-COMMITTEE.md @@ -0,0 +1,15 @@ +# Steering Committee + +This document lists the members of the Organization's Steering Committee (in alphabetical order). Voting members may be added once approved by the Steering Committee as described in the [charter](github.com/mathLab/PINA/blob/master/CHARTER.md). By adding your name to this list you are agreeing to abide by all Organization polices, including the [charter](github.com/mathLab/PINA/blob/master/CHARTER.md), the [code of conduct](https://github.com/mathLab/PINA/blob/master/CODE_OF_CONDUCT.md), the [trademark policy](https://github.com/mathLab/PINA/blob/master/TRADEMARKS.md), and the [antitrust policy](https://github.com/mathLab/PINA/blob/master/ANTITRUST.md). If you are serving on the Steering Committee because of your affiliation with another organization (designated below), you represent that you have authority to bind that organization to these policies. + +| **NAME** | **Handle** | **Affiliated Organization** | +| ------------ | ------------ | --------------------------- | +| Giovanni Canali | @GiovanniCanali | SISSA | +| Dario Coscia | @dario-coscia | SISSA | +| Nicola Demo | @ndem0 | SISSA - FAST COMPUTING SRL | +| Filippo Olivo | @FilippoOlivo | SISSA - FAST COMPUTING SRL | + +--- +## Attribution +This file is adapted from the [Minimum Viable Governance][https://github.com/github/MVG], +homepage, Licensed under the [CC-BY 4.0 License](https://creativecommons.org/licenses/by/4.0/). diff --git a/TRADEMARKS.md b/TRADEMARKS.md new file mode 100644 index 000000000..c7b25824d --- /dev/null +++ b/TRADEMARKS.md @@ -0,0 +1,44 @@ +## Introduction + +This is the Organization's policy for the use of our trademarks. While our work is available under free and open source software licenses, those licenses do not include a license to use our trademarks. + +This policy describes how you may use our trademarks. Our goal is to strike a balance between: 1) our need to ensure that our trademarks remain reliable indicators of the quality software we release; and 2) our community members' desire to be full participants in our Organization. + +## Our Trademarks + +This policy covers the name of the Organization and each of the Organization's projects, as well as any associated names, trademarks, service marks, logos, mascots, or similar indicators of source or origin (our "Marks"). + +## In General + +Whenever you use our Marks, you must always do so in a way that does not mislead anyone about exactly who is the source of the software. For example, you cannot say you are distributing the "Mark" software when you're distributing a modified version of it because people will believe they are getting the same software that they can get directly from us when they aren't. You also cannot use our Marks on your website in a way that suggests that your website is an official Organization website or that we endorse your website. But, if true, you can say you like the "Mark" software, that you participate in the "Mark" community, that you are providing an unmodified version of the "Mark" software, or that you wrote a book describing how to use the "Mark" software. + +This fundamental requirement, that it is always clear to people what they are getting and from whom, is reflected throughout this policy. It should also serve as your guide if you are not sure about how you are using the Marks. + +In addition: +* You may not use or register, in whole or in part, the Marks as part of your own trademark, service mark, domain name, company name, trade name, product name or service name. +* Trademark law does not allow your use of names or trademarks that are too similar to ours. You therefore may not use an obvious variation of any of our Marks or any phonetic equivalent, foreign language equivalent, takeoff, or abbreviation for a similar or compatible product or service. +* You agree that any goodwill generated by your use of the Marks and participation in our community inures solely to our collective benefit. + +## Distribution of unmodified source code or unmodified executable code we have compiled + +When you redistribute an unmodified copy of our software, you are not changing the quality or nature of it. Therefore, you may retain the Marks we have placed on the software to identify your redistribution. This kind of use only applies if you are redistributing an official distribution from this Project that has not been changed in any way. + +## Distribution of executable code that you have compiled, or modified code + +You may use any word marks, but not any Organization logos, to truthfully describe the origin of the software that you are providing, that is, that the code you are distributing is a modification of our software. You may say, for example, that "this software is derived from the source code for 'Mark' software." + +Of course, you can place your own trademarks or logos on versions of the software to which you have made substantive modifications, because by modifying the software, you have become the origin of that exact version. In that case, you should not use our Marks. + +However, you may use our Marks for the distribution of code (source or executable) on the condition that any executable is built from the official Project source code and that any modifications are limited to switching on or off features already included in the software, translations into other languages, and incorporating minor bug-fix patches. Use of our Marks on any further modification is not permitted. + +## Statements about your software's relation to our software + +You may use the word Marks, but not the Organization's logos, to truthfully describe the relationship between your software and ours. Our Mark should be used after a verb or preposition that describes the relationship between your software and ours. So you may say, for example, "Bob's software for the 'Mark' platform" but may not say "Bob's 'Mark' software." Some other examples that may work for you are: + +* [Your software] uses "Mark" software +* [Your software] is powered by "Mark" software +* [Your software] runs on "Mark" software +* [Your software] for use with "Mark" software +* [Your software] for Mark software + +These guidelines are based on the [Model Trademark Guidelines](http://www.modeltrademarkguidelines.org), used under a [Creative Commons Attribution 3.0 Unported license](https://creativecommons.org/licenses/by/3.0/deed.en_US) \ No newline at end of file diff --git a/docs/source/_rst/_code.rst b/docs/source/_rst/_code.rst index 9bd36ab2d..160eb3542 100644 --- a/docs/source/_rst/_code.rst +++ b/docs/source/_rst/_code.rst @@ -253,7 +253,7 @@ Callbacks Optimizer callback R3 Refinment callback Refinment Interface callback - Weighting callback + Normalizer callback Losses and Weightings --------------------- @@ -267,3 +267,5 @@ Losses and Weightings WeightingInterface ScalarWeighting NeuralTangentKernelWeighting + SelfAdaptiveWeighting + LinearWeighting \ No newline at end of file diff --git a/docs/source/_rst/callback/linear_weight_update_callback.rst b/docs/source/_rst/callback/linear_weight_update_callback.rst deleted file mode 100644 index fe45b56e2..000000000 --- a/docs/source/_rst/callback/linear_weight_update_callback.rst +++ /dev/null @@ -1,7 +0,0 @@ -Weighting callbacks -======================== - -.. currentmodule:: pina.callback.linear_weight_update_callback -.. autoclass:: LinearWeightUpdate - :members: - :show-inheritance: \ No newline at end of file diff --git a/docs/source/_rst/callback/normalizer_data_callback.rst b/docs/source/_rst/callback/normalizer_data_callback.rst new file mode 100644 index 000000000..6f59f7aee --- /dev/null +++ b/docs/source/_rst/callback/normalizer_data_callback.rst @@ -0,0 +1,7 @@ +Normalizer callbacks +======================= + +.. currentmodule:: pina.callback.normalizer_data_callback +.. autoclass:: NormalizerDataCallback + :members: + :show-inheritance: \ No newline at end of file diff --git a/docs/source/_rst/equation/equation_factory.rst b/docs/source/_rst/equation/equation_factory.rst index cf5d430d3..86390c6bd 100644 --- a/docs/source/_rst/equation/equation_factory.rst +++ b/docs/source/_rst/equation/equation_factory.rst @@ -14,6 +14,30 @@ Equation Factory :members: :show-inheritance: +.. autoclass:: FixedLaplacian + :members: + :show-inheritance: + .. autoclass:: Laplace + :members: + :show-inheritance: + +.. autoclass:: Advection + :members: + :show-inheritance: + +.. autoclass:: AllenCahn + :members: + :show-inheritance: + +.. autoclass:: DiffusionReaction + :members: + :show-inheritance: + +.. autoclass:: Helmholtz + :members: + :show-inheritance: + +.. autoclass:: Poisson :members: :show-inheritance: \ No newline at end of file diff --git a/docs/source/_rst/loss/linear_weighting.rst b/docs/source/_rst/loss/linear_weighting.rst new file mode 100644 index 000000000..16e6232d0 --- /dev/null +++ b/docs/source/_rst/loss/linear_weighting.rst @@ -0,0 +1,9 @@ +LinearWeighting +============================= +.. currentmodule:: pina.loss.linear_weighting + +.. automodule:: pina.loss.linear_weighting + +.. autoclass:: LinearWeighting + :members: + :show-inheritance: diff --git a/docs/source/_rst/loss/self_adaptive_weighting.rst b/docs/source/_rst/loss/self_adaptive_weighting.rst new file mode 100644 index 000000000..cd1daed1f --- /dev/null +++ b/docs/source/_rst/loss/self_adaptive_weighting.rst @@ -0,0 +1,9 @@ +SelfAdaptiveWeighting +============================= +.. currentmodule:: pina.loss.self_adaptive_weighting + +.. automodule:: pina.loss.self_adaptive_weighting + +.. autoclass:: SelfAdaptiveWeighting + :members: + :show-inheritance: \ No newline at end of file diff --git a/docs/source/_tutorial.rst b/docs/source/_tutorial.rst index 612320a19..2eb9c1c58 100644 --- a/docs/source/_tutorial.rst +++ b/docs/source/_tutorial.rst @@ -38,6 +38,7 @@ Supervised Learning ------------------- - `Introductory Tutorial: Supervised Learning with PINA `_ -- `Chemical Properties Prediction with Graph Neural Networks `_ +- `Chemical Properties Prediction with Graph Neural Networks `_ +- `Reduced Order Model with Graph Neural Networks for Unstructured Domains `_ - `Unstructured Convolutional Autoencoders with Continuous Convolution `_ - `Reduced Order Modeling with POD-RBF and POD-NN Approaches for Fluid Dynamics `_ diff --git a/docs/source/tutorials/tutorial15/tutorial.html b/docs/source/tutorials/tutorial15/tutorial.html index 9de416c83..3fadabe83 100644 --- a/docs/source/tutorials/tutorial15/tutorial.html +++ b/docs/source/tutorials/tutorial15/tutorial.html @@ -7747,7 +7747,7 @@

Download Data and create the Probl # save the dataset input_ = [data for data in dataset] -target_ = torch.stack([data.y for data in dataset]) +target_ = torch.cat([data.y for data in dataset]) # normalize the target mean = target_.mean(dim=0, keepdim=True) @@ -7908,7 +7908,7 @@

Train the Model @@ -7935,56 +7935,56 @@

Train the Model - @@ -7867,7 +7867,7 @@

KernelNeuralOperator API @@ -7894,12 +7894,20 @@

KernelNeuralOperator API @@ -8009,6 +8017,6 @@

What's Next? diff --git a/docs/source/tutorials/tutorial22/tutorial.html b/docs/source/tutorials/tutorial22/tutorial.html new file mode 100644 index 000000000..16f9bc598 --- /dev/null +++ b/docs/source/tutorials/tutorial22/tutorial.html @@ -0,0 +1,11524 @@ + + + + + +tutorial + + + + + + + + + + + + +
+ + + + + + + + + + + +
+ + + diff --git a/pina/adaptive_functions/__init__.py b/pina/adaptive_functions/__init__.py deleted file mode 100644 index 6df3338c0..000000000 --- a/pina/adaptive_functions/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -"""Old module for adaptive functions. Deprecated in 0.2.0.""" - -import warnings - -from ..adaptive_function import * -from ..utils import custom_warning_format - -# back-compatibility 0.1 -# Set the custom format for warnings -warnings.formatwarning = custom_warning_format -warnings.filterwarnings("always", category=DeprecationWarning) -warnings.warn( - "'pina.adaptive_functions' is deprecated and will be removed " - "in future versions. Please use 'pina.adaptive_function' instead.", - DeprecationWarning, -) diff --git a/pina/callback/__init__.py b/pina/callback/__init__.py index dc1164e47..f71a89f91 100644 --- a/pina/callback/__init__.py +++ b/pina/callback/__init__.py @@ -4,11 +4,11 @@ "SwitchOptimizer", "MetricTracker", "PINAProgressBar", - "LinearWeightUpdate", "R3Refinement", + "NormalizerDataCallback", ] from .optimizer_callback import SwitchOptimizer from .processing_callback import MetricTracker, PINAProgressBar -from .linear_weight_update_callback import LinearWeightUpdate from .refinement import R3Refinement +from .normalizer_data_callback import NormalizerDataCallback diff --git a/pina/callback/linear_weight_update_callback.py b/pina/callback/linear_weight_update_callback.py deleted file mode 100644 index ae25ca158..000000000 --- a/pina/callback/linear_weight_update_callback.py +++ /dev/null @@ -1,87 +0,0 @@ -"""Module for the LinearWeightUpdate callback.""" - -import warnings -from lightning.pytorch.callbacks import Callback -from ..utils import check_consistency -from ..loss import ScalarWeighting - - -class LinearWeightUpdate(Callback): - """ - Callback to linearly adjust the weight of a condition from an - initial value to a target value over a specified number of epochs. - """ - - def __init__( - self, target_epoch, condition_name, initial_value, target_value - ): - """ - Callback initialization. - - :param int target_epoch: The epoch at which the weight of the condition - should reach the target value. - :param str condition_name: The name of the condition whose weight - should be adjusted. - :param float initial_value: The initial value of the weight. - :param float target_value: The target value of the weight. - """ - super().__init__() - self.target_epoch = target_epoch - self.condition_name = condition_name - self.initial_value = initial_value - self.target_value = target_value - - # Check consistency - check_consistency(self.target_epoch, int, subclass=False) - check_consistency(self.condition_name, str, subclass=False) - check_consistency(self.initial_value, (float, int), subclass=False) - check_consistency(self.target_value, (float, int), subclass=False) - - def on_train_start(self, trainer, pl_module): - """ - Initialize the weight of the condition to the specified `initial_value`. - - :param Trainer trainer: A :class:`~pina.trainer.Trainer` instance. - :param SolverInterface pl_module: A - :class:`~pina.solver.solver.SolverInterface` instance. - """ - # Check that the target epoch is valid - if not 0 < self.target_epoch <= trainer.max_epochs: - raise ValueError( - "`target_epoch` must be greater than 0" - " and less than or equal to `max_epochs`." - ) - - # Check that the condition is a problem condition - if self.condition_name not in pl_module.problem.conditions: - raise ValueError( - f"`{self.condition_name}` must be a problem condition." - ) - - # Check that the initial value is not equal to the target value - if self.initial_value == self.target_value: - warnings.warn( - "`initial_value` is equal to `target_value`. " - "No effective adjustment will be performed.", - UserWarning, - ) - - # Check that the weighting schema is ScalarWeighting - if not isinstance(pl_module.weighting, ScalarWeighting): - raise ValueError("The weighting schema must be ScalarWeighting.") - - # Initialize the weight of the condition - pl_module.weighting.weights[self.condition_name] = self.initial_value - - def on_train_epoch_start(self, trainer, pl_module): - """ - Adjust at each epoch the weight of the condition. - - :param Trainer trainer: A :class:`~pina.trainer.Trainer` instance. - :param SolverInterface pl_module: A - :class:`~pina.solver.solver.SolverInterface` instance. - """ - if 0 < trainer.current_epoch <= self.target_epoch: - pl_module.weighting.weights[self.condition_name] += ( - self.target_value - self.initial_value - ) / (self.target_epoch - 1) diff --git a/pina/callback/normalizer_data_callback.py b/pina/callback/normalizer_data_callback.py new file mode 100644 index 000000000..ef957b9ef --- /dev/null +++ b/pina/callback/normalizer_data_callback.py @@ -0,0 +1,228 @@ +"""Module for the Normalizer callback.""" + +import torch +from lightning.pytorch import Callback +from ..label_tensor import LabelTensor +from ..utils import check_consistency, is_function +from ..condition import InputTargetCondition +from ..data.dataset import PinaGraphDataset + + +class NormalizerDataCallback(Callback): + r""" + A Callback used to normalize the dataset inputs or targets according to + user-provided scale and shift functions. + + The transformation is applied as: + + .. math:: + + x_{\text{new}} = \frac{x - \text{shift}}{\text{scale}} + + :Example: + + >>> NormalizerDataCallback() + >>> NormalizerDataCallback( + ... scale_fn: torch.std, + ... shift_fn: torch.mean, + ... stage: "all", + ... apply_to: "input", + ... ) + """ + + def __init__( + self, + scale_fn=torch.std, + shift_fn=torch.mean, + stage="all", + apply_to="input", + ): + """ + Initialization of the :class:`NormalizerDataCallback` class. + + :param Callable scale_fn: The function to compute the scaling factor. + Default is ``torch.std``. + :param Callable shift_fn: The function to compute the shifting factor. + Default is ``torch.mean``. + :param str stage: The stage in which normalization is applied. + Accepted values are "train", "validate", "test", or "all". + Default is ``"all"``. + :param str apply_to: Whether to normalize "input" or "target" data. + Default is ``"input"``. + :raises ValueError: If ``scale_fn`` is not callable. + :raises ValueError: If ``shift_fn`` is not callable. + """ + super().__init__() + + # Validate parameters + self.apply_to = self._validate_apply_to(apply_to) + self.stage = self._validate_stage(stage) + + # Validate functions + if not is_function(scale_fn): + raise ValueError(f"scale_fn must be Callable, got {scale_fn}") + if not is_function(shift_fn): + raise ValueError(f"shift_fn must be Callable, got {shift_fn}") + self.scale_fn = scale_fn + self.shift_fn = shift_fn + + # Initialize normalizer dictionary + self._normalizer = {} + + def _validate_apply_to(self, apply_to): + """ + Validate the ``apply_to`` parameter. + + :param str apply_to: The candidate value for the ``apply_to`` parameter. + :raises ValueError: If ``apply_to`` is neither "input" nor "target". + :return: The validated ``apply_to`` value. + :rtype: str + """ + check_consistency(apply_to, str) + if apply_to not in {"input", "target"}: + raise ValueError( + f"apply_to must be either 'input' or 'target', got {apply_to}" + ) + + return apply_to + + def _validate_stage(self, stage): + """ + Validate the ``stage`` parameter. + + :param str stage: The candidate value for the ``stage`` parameter. + :raises ValueError: If ``stage`` is not one of "train", "validate", + "test", or "all". + :return: The validated ``stage`` value. + :rtype: str + """ + check_consistency(stage, str) + if stage not in {"train", "validate", "test", "all"}: + raise ValueError( + "stage must be one of 'train', 'validate', 'test', or 'all'," + f" got {stage}" + ) + + return stage + + def setup(self, trainer, pl_module, stage): + """ + Apply normalization during setup. + + :param Trainer trainer: A :class:`~pina.trainer.Trainer` instance. + :param SolverInterface pl_module: A + :class:`~pina.solver.solver.SolverInterface` instance. + :param str stage: The current stage. + :raises RuntimeError: If the training dataset is not available when + computing normalization parameters. + :return: The result of the parent setup. + :rtype: Any + + :raises NotImplementedError: If the dataset is graph-based. + """ + + # Ensure datsets are not graph-based + if isinstance(trainer.datamodule.train_dataset, PinaGraphDataset): + raise NotImplementedError( + "NormalizerDataCallback is not compatible with " + "graph-based datasets." + ) + + # Extract conditions + conditions_to_normalize = [ + name + for name, cond in pl_module.problem.conditions.items() + if isinstance(cond, InputTargetCondition) + ] + + # Compute scale and shift parameters + if not self.normalizer: + if not trainer.datamodule.train_dataset: + raise RuntimeError( + "Training dataset is not available. Cannot compute " + "normalization parameters." + ) + self._compute_scale_shift( + conditions_to_normalize, trainer.datamodule.train_dataset + ) + + # Apply normalization based on the specified stage + if stage == "fit" and self.stage in ["train", "all"]: + self.normalize_dataset(trainer.datamodule.train_dataset) + if stage == "fit" and self.stage in ["validate", "all"]: + self.normalize_dataset(trainer.datamodule.val_dataset) + if stage == "test" and self.stage in ["test", "all"]: + self.normalize_dataset(trainer.datamodule.test_dataset) + + return super().setup(trainer, pl_module, stage) + + def _compute_scale_shift(self, conditions, dataset): + """ + Compute scale and shift parameters for each condition in the dataset. + + :param list conditions: The list of condition names. + :param dataset: The `~pina.data.dataset.PinaDataset` dataset. + """ + for cond in conditions: + if cond in dataset.conditions_dict: + data = dataset.conditions_dict[cond][self.apply_to] + shift = self.shift_fn(data) + scale = self.scale_fn(data) + self._normalizer[cond] = { + "shift": shift, + "scale": scale, + } + + @staticmethod + def _norm_fn(value, scale, shift): + """ + Normalize a value according to the scale and shift parameters. + + :param value: The input tensor to normalize. + :type value: torch.Tensor | LabelTensor + :param float scale: The scaling factor. + :param float shift: The shifting factor. + :return: The normalized tensor. + :rtype: torch.Tensor | LabelTensor + """ + scaled_value = (value - shift) / scale + if isinstance(value, LabelTensor): + scaled_value = LabelTensor(scaled_value, value.labels) + + return scaled_value + + def normalize_dataset(self, dataset): + """ + Apply in-place normalization to the dataset. + + :param PinaDataset dataset: The dataset to be normalized. + """ + # Initialize update dictionary + update_dataset_dict = {} + + # Iterate over conditions and apply normalization + for cond, norm_params in self.normalizer.items(): + points = dataset.conditions_dict[cond][self.apply_to] + scale = norm_params["scale"] + shift = norm_params["shift"] + normalized_points = self._norm_fn(points, scale, shift) + update_dataset_dict[cond] = { + self.apply_to: ( + LabelTensor(normalized_points, points.labels) + if isinstance(points, LabelTensor) + else normalized_points + ) + } + + # Update the dataset in-place + dataset.update_data(update_dataset_dict) + + @property + def normalizer(self): + """ + Get the dictionary of normalization parameters. + + :return: The dictionary of normalization parameters. + :rtype: dict + """ + return self._normalizer diff --git a/pina/callbacks/__init__.py b/pina/callbacks/__init__.py deleted file mode 100644 index 69f8782f6..000000000 --- a/pina/callbacks/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -"""Old module for callbacks. Deprecated in 0.2.0.""" - -import warnings - -from ..callback import * -from ..utils import custom_warning_format - -# back-compatibility 0.1 -# Set the custom format for warnings -warnings.formatwarning = custom_warning_format -warnings.filterwarnings("always", category=DeprecationWarning) -warnings.warn( - "'pina.callbacks' is deprecated and will be removed " - "in future versions. Please use 'pina.callback' instead.", - DeprecationWarning, -) diff --git a/pina/condition/condition.py b/pina/condition/condition.py index 05a377eab..ad8764c9f 100644 --- a/pina/condition/condition.py +++ b/pina/condition/condition.py @@ -1,100 +1,91 @@ """Module for the Condition class.""" -import warnings from .data_condition import DataCondition from .domain_equation_condition import DomainEquationCondition from .input_equation_condition import InputEquationCondition from .input_target_condition import InputTargetCondition -from ..utils import custom_warning_format -# Set the custom format for warnings -warnings.formatwarning = custom_warning_format -warnings.filterwarnings("always", category=DeprecationWarning) +class Condition: + """ + The :class:`Condition` class is a core component of the PINA framework that + provides a unified interface to define heterogeneous constraints that must + be satisfied by a :class:`~pina.problem.abstract_problem.AbstractProblem`. -def warning_function(new, old): - """Handle the deprecation warning. + It encapsulates all types of constraints - physical, boundary, initial, or + data-driven - that the solver must satisfy during training. The specific + behavior is inferred from the arguments passed to the constructor. - :param new: Object to use instead of the old one. - :type new: str - :param old: Object to deprecate. - :type old: str - """ - warnings.warn( - f"'{old}' is deprecated and will be removed " - f"in future versions. Please use '{new}' instead.", - DeprecationWarning, - ) + Multiple types of conditions can be used within the same problem, allowing + for a high degree of flexibility in defining complex problems. + The :class:`Condition` class behavior specializes internally based on the + arguments provided during instantiation. Depending on the specified keyword + arguments, the class automatically selects the appropriate internal + implementation. -class Condition: - """ - Represents constraints (such as physical equations, boundary conditions, - etc.) that must be satisfied in a given problem. Condition objects are used - to formulate the PINA - :class:`~pina.problem.abstract_problem.AbstractProblem` object. - There are different types of conditions: + Available `Condition` types: - :class:`~pina.condition.input_target_condition.InputTargetCondition`: - Defined by specifying both the input and the target of the condition. In - this case, the model is trained to produce the target given the input. The - input and output data must be one of the :class:`torch.Tensor`, - :class:`~pina.label_tensor.LabelTensor`, - :class:`~torch_geometric.data.Data`, or :class:`~pina.graph.Graph`. - Different implementations exist depending on the type of input and target. - For more details, see - :class:`~pina.condition.input_target_condition.InputTargetCondition`. + represents a supervised condition defined by both ``input`` and ``target`` + data. The model is trained to reproduce the ``target`` values given the + ``input``. Supported data types include :class:`torch.Tensor`, + :class:`~pina.label_tensor.LabelTensor`, :class:`~pina.graph.Graph`, or + :class:`~torch_geometric.data.Data`. + The class automatically selects the appropriate implementation based on + the types of ``input`` and ``target``. - :class:`~pina.condition.domain_equation_condition.DomainEquationCondition` - : Defined by specifying both the domain and the equation of the condition. - Here, the model is trained to minimize the equation residual by evaluating - it at sampled points within the domain. + : represents a general physics-informed condition defined by a ``domain`` + and an ``equation``. The model learns to minimize the equation residual + through evaluations performed at points sampled from the specified domain. - :class:`~pina.condition.input_equation_condition.InputEquationCondition`: - Defined by specifying the input and the equation of the condition. In this - case, the model is trained to minimize the equation residual by evaluating - it at the provided input. The input must be either a - :class:`~pina.label_tensor.LabelTensor` or a :class:`~pina.graph.Graph`. - Different implementations exist depending on the type of input. For more - details, see - :class:`~pina.condition.input_equation_condition.InputEquationCondition`. - - - :class:`~pina.condition.data_condition.DataCondition`: - Defined by specifying only the input. In this case, the model is trained - with an unsupervised custom loss while using the provided data during - training. The input data must be one of :class:`torch.Tensor`, - :class:`~pina.label_tensor.LabelTensor`, - :class:`~torch_geometric.data.Data`, or :class:`~pina.graph.Graph`. - Additionally, conditional variables can be provided when the model - depends on extra parameters. These conditional variables must be either - :class:`torch.Tensor` or :class:`~pina.label_tensor.LabelTensor`. - Different implementations exist depending on the type of input. - For more details, see - :class:`~pina.condition.data_condition.DataCondition`. + represents a general physics-informed condition defined by ``input`` + points and an ``equation``. The model learns to minimize the equation + residual through evaluations performed at the provided ``input``. + Supported data types for the ``input`` include + :class:`~pina.label_tensor.LabelTensor` or :class:`~pina.graph.Graph`. + The class automatically selects the appropriate implementation based on + the types of the ``input``. + + - :class:`~pina.condition.data_condition.DataCondition`: represents an + unsupervised, data-driven condition defined by the ``input`` only. + The model is trained using a custom unsupervised loss determined by the + chosen :class:`~pina.solver.solver.SolverInterface`, while leveraging the + provided data during training. Optional ``conditional_variables`` can be + specified when the model depends on additional parameters. + Supported data types include :class:`torch.Tensor`, + :class:`~pina.label_tensor.LabelTensor`, :class:`~pina.graph.Graph`, or + :class:`~torch_geometric.data.Data`. + The class automatically selects the appropriate implementation based on + the type of the ``input``. + + .. note:: + + The user should always instantiate :class:`Condition` directly, without + manually creating subclass instances. Please refer to the specific + :class:`Condition` classes for implementation details. :Example: >>> from pina import Condition - >>> condition = Condition( - ... input=input, - ... target=target - ... ) - >>> condition = Condition( - ... domain=location, - ... equation=equation - ... ) - >>> condition = Condition( - ... input=input, - ... equation=equation - ... ) - >>> condition = Condition( - ... input=data, - ... conditional_variables=conditional_variables - ... ) + >>> # Example of InputTargetCondition signature + >>> condition = Condition(input=input, target=target) + + >>> # Example of DomainEquationCondition signature + >>> condition = Condition(domain=domain, equation=equation) + + >>> # Example of InputEquationCondition signature + >>> condition = Condition(input=input, equation=equation) + + >>> # Example of DataCondition signature + >>> condition = Condition(input=data, conditional_variables=cond_vars) """ + # Combine all possible keyword arguments from the different Condition types __slots__ = list( set( InputTargetCondition.__slots__ @@ -106,46 +97,45 @@ class Condition: def __new__(cls, *args, **kwargs): """ - Instantiate the appropriate Condition object based on the keyword - arguments passed. + Instantiate the appropriate :class:`Condition` object based on the + keyword arguments passed. - :raises ValueError: If no keyword arguments are passed. + :param tuple args: The positional arguments (should be empty). + :param dict kwargs: The keyword arguments corresponding to the + parameters of the specific :class:`Condition` type to instantiate. + :raises ValueError: If unexpected positional arguments are provided. :raises ValueError: If the keyword arguments are invalid. - :return: The appropriate Condition object. + :return: The appropriate :class:`Condition` object. :rtype: ConditionInterface """ - + # Check keyword arguments if len(args) != 0: raise ValueError( "Condition takes only the following keyword " f"arguments: {Condition.__slots__}." ) - # back-compatibility 0.1 - keys = list(kwargs.keys()) - if "location" in keys: - kwargs["domain"] = kwargs.pop("location") - warning_function(new="domain", old="location") - - if "input_points" in keys: - kwargs["input"] = kwargs.pop("input_points") - warning_function(new="input", old="input_points") - - if "output_points" in keys: - kwargs["target"] = kwargs.pop("output_points") - warning_function(new="target", old="output_points") - + # Class specialization based on keyword arguments sorted_keys = sorted(kwargs.keys()) + + # Input - Target Condition if sorted_keys == sorted(InputTargetCondition.__slots__): return InputTargetCondition(**kwargs) + + # Input - Equation Condition if sorted_keys == sorted(InputEquationCondition.__slots__): return InputEquationCondition(**kwargs) + + # Domain - Equation Condition if sorted_keys == sorted(DomainEquationCondition.__slots__): return DomainEquationCondition(**kwargs) + + # Data Condition if ( sorted_keys == sorted(DataCondition.__slots__) or sorted_keys[0] == DataCondition.__slots__[0] ): return DataCondition(**kwargs) + # Invalid keyword arguments raise ValueError(f"Invalid keyword arguments {kwargs.keys()}.") diff --git a/pina/condition/condition_interface.py b/pina/condition/condition_interface.py index ee20845bb..b0264517c 100644 --- a/pina/condition/condition_interface.py +++ b/pina/condition/condition_interface.py @@ -8,24 +8,25 @@ class ConditionInterface(metaclass=ABCMeta): """ - Abstract class which defines a common interface for all the conditions. - It defined a common interface for all the conditions. + Abstract base class for PINA conditions. All specific conditions must + inherit from this interface. + Refer to :class:`pina.condition.condition.Condition` for a thorough + description of all available conditions and how to instantiate them. """ def __init__(self): """ - Initialize the ConditionInterface object. + Initialization of the :class:`ConditionInterface` class. """ - self._problem = None @property def problem(self): """ - Return the problem to which the condition is associated. + Return the problem associated with this condition. - :return: Problem to which the condition is associated. + :return: Problem associated with this condition. :rtype: ~pina.problem.abstract_problem.AbstractProblem """ return self._problem @@ -33,31 +34,32 @@ def problem(self): @problem.setter def problem(self, value): """ - Set the problem to which the condition is associated. + Set the problem associated with this condition. - :param pina.problem.abstract_problem.AbstractProblem value: Problem to - which the condition is associated + :param pina.problem.abstract_problem.AbstractProblem value: The problem + to associate with this condition """ self._problem = value @staticmethod def _check_graph_list_consistency(data_list): """ - Check the consistency of the list of Data/Graph objects. It performs - the following checks: - - 1. All elements in the list must be of the same type (either Data or - Graph). - 2. All elements in the list must have the same keys. - 3. The type of each tensor must be consistent across all elements in - the list. - 4. If the tensor is a LabelTensor, the labels must be consistent across - all elements in the list. - - :param data_list: List of Data/Graph objects to check - :type data_list: list[Data] | list[Graph] | tuple[Data] | tuple[Graph] + Check the consistency of the list of Data | Graph objects. + The following checks are performed: + + - All elements in the list must be of the same type (either + :class:`~torch_geometric.data.Data` or :class:`~pina.graph.Graph`). + + - All elements in the list must have the same keys. + + - The data type of each tensor must be consistent across all elements. - :raises ValueError: If the input types are invalid. + - If a tensor is a :class:`~pina.label_tensor.LabelTensor`, its labels + must also be consistent across all elements. + + :param data_list: The list of Data | Graph objects to check. + :type data_list: list[Data] | list[Graph] | tuple[Data] | tuple[Graph] + :raises ValueError: If the input types are invalid. :raises ValueError: If all elements in the list do not have the same keys. :raises ValueError: If the type of each tensor is not consistent across @@ -65,51 +67,45 @@ def _check_graph_list_consistency(data_list): :raises ValueError: If the labels of the LabelTensors are not consistent across all elements in the list. """ - - # If the data is a Graph or Data object, return (do not need to check - # anything) + # If the data is a Graph or Data object, perform no checks if isinstance(data_list, (Graph, Data)): return - # check all elements in the list are of the same type + # Check all elements in the list are of the same type if not all(isinstance(i, (Graph, Data)) for i in data_list): raise ValueError( - "Invalid input types. " - "Please provide either Data or Graph objects." + "Invalid input. Please, provide either Data or Graph objects." ) + + # Store the keys, data types and labels of the first element data = data_list[0] - # Store the keys of the first element in the list keys = sorted(list(data.keys())) - - # Store the type of each tensor inside first element Data/Graph object data_types = {name: tensor.__class__ for name, tensor in data.items()} - - # Store the labels of each LabelTensor inside first element Data/Graph - # object labels = { name: tensor.labels for name, tensor in data.items() if isinstance(tensor, LabelTensor) } - # Iterate over the list of Data/Graph objects + # Iterate over the list of Data | Graph objects for data in data_list[1:]: - # Check if the keys of the current element are the same as the first - # element + + # Check that all elements in the list have the same keys if sorted(list(data.keys())) != keys: raise ValueError( "All elements in the list must have the same keys." ) + + # Iterate over the tensors in the current element for name, tensor in data.items(): - # Check if the type of each tensor inside the current element - # is the same as the first element + # Check that the type of each tensor is consistent if tensor.__class__ is not data_types[name]: raise ValueError( f"Data {name} must be a {data_types[name]}, got " f"{tensor.__class__}" ) - # If the tensor is a LabelTensor, check if the labels are the - # same as the first element + + # Check that the labels of each LabelTensor are consistent if isinstance(tensor, LabelTensor): if tensor.labels != labels[name]: raise ValueError( @@ -117,6 +113,13 @@ def _check_graph_list_consistency(data_list): ) def __getattribute__(self, name): + """ + Get an attribute from the object. + + :param str name: The name of the attribute to get. + :return: The requested attribute. + :rtype: Any + """ to_return = super().__getattribute__(name) if isinstance(to_return, (Graph, Data)): to_return = [to_return] diff --git a/pina/condition/data_condition.py b/pina/condition/data_condition.py index 4ecd0aefb..e948305fe 100644 --- a/pina/condition/data_condition.py +++ b/pina/condition/data_condition.py @@ -9,16 +9,35 @@ class DataCondition(ConditionInterface): """ - Condition defined by input data and conditional variables. It can be used - in unsupervised learning problems. Based on the type of the input, - different condition implementations are available: - - - :class:`TensorDataCondition`: For :class:`torch.Tensor` or - :class:`~pina.label_tensor.LabelTensor` input data. - - :class:`GraphDataCondition`: For :class:`~pina.graph.Graph` or - :class:`~torch_geometric.data.Data` input data. + The class :class:`DataCondition` defines an unsupervised condition based on + ``input`` data. This condition is typically used in data-driven problems, + where the model is trained using a custom unsupervised loss determined by + the chosen :class:`~pina.solver.solver.SolverInterface`, while leveraging + the provided data during training. Optional ``conditional_variables`` can be + specified when the model depends on additional parameters. + + The class automatically selects the appropriate implementation based on the + type of the ``input`` data. Depending on whether the ``input`` is a tensor + or graph-based data, one of the following specialized subclasses is + instantiated: + + - :class:`TensorDataCondition`: For cases where the ``input`` is either a + :class:`torch.Tensor` or a :class:`~pina.label_tensor.LabelTensor` object. + + - :class:`GraphDataCondition`: For cases where the ``input`` is either a + :class:`~pina.graph.Graph` or :class:`~torch_geometric.data.Data` object. + + :Example: + + >>> from pina import Condition, LabelTensor + >>> import torch + + >>> pts = LabelTensor(torch.randn(100, 2), labels=["x", "y"]) + >>> cond_vars = LabelTensor(torch.randn(100, 1), labels=["w"]) + >>> condition = Condition(input=pts, conditional_variables=cond_vars) """ + # Available input data types __slots__ = ["input", "conditional_variables"] _avail_input_cls = (torch.Tensor, LabelTensor, Data, Graph, list, tuple) _avail_conditional_variables_cls = (torch.Tensor, LabelTensor) @@ -26,33 +45,36 @@ class DataCondition(ConditionInterface): def __new__(cls, input, conditional_variables=None): """ Instantiate the appropriate subclass of :class:`DataCondition` based on - the type of ``input``. + the type of the ``input``. - :param input: Input data for the condition. + :param input: The input data for the condition. :type input: torch.Tensor | LabelTensor | Graph | Data | list[Graph] | list[Data] | tuple[Graph] | tuple[Data] - :param conditional_variables: Conditional variables for the condition. - :type conditional_variables: torch.Tensor | LabelTensor, optional - :return: Subclass of DataCondition. + :param conditional_variables: The conditional variables for the + condition. Default is ``None``. + :type conditional_variables: torch.Tensor | LabelTensor + :return: The subclass of DataCondition. :rtype: pina.condition.data_condition.TensorDataCondition | pina.condition.data_condition.GraphDataCondition - - :raises ValueError: If input is not of type :class:`torch.Tensor`, + :raises ValueError: If ``input`` is not of type :class:`torch.Tensor`, :class:`~pina.label_tensor.LabelTensor`, :class:`~pina.graph.Graph`, or :class:`~torch_geometric.data.Data`. """ - if cls != DataCondition: return super().__new__(cls) + + # If the input is a tensor if isinstance(input, (torch.Tensor, LabelTensor)): subclass = TensorDataCondition return subclass.__new__(subclass, input, conditional_variables) + # If the input is a graph if isinstance(input, (Graph, Data, list, tuple)): cls._check_graph_list_consistency(input) subclass = GraphDataCondition return subclass.__new__(subclass, input, conditional_variables) + # If the input is not of the correct type raise an error raise ValueError( "Invalid input types. " "Please provide either torch_geometric.data.Data or Graph objects." @@ -60,21 +82,22 @@ def __new__(cls, input, conditional_variables=None): def __init__(self, input, conditional_variables=None): """ - Initialize the object by storing the input and conditional - variables (if any). + Initialization of the :class:`DataCondition` class. - :param input: Input data for the condition. + :param input: The input data for the condition. :type input: torch.Tensor | LabelTensor | Graph | Data | list[Graph] | list[Data] | tuple[Graph] | tuple[Data] - :param conditional_variables: Conditional variables for the condition. + :param conditional_variables: The conditional variables for the + condition. Default is ``None``. :type conditional_variables: torch.Tensor | LabelTensor .. note:: - If ``input`` consists of a list of :class:`~pina.graph.Graph` or - :class:`~torch_geometric.data.Data`, all elements must have the same - structure (keys and data types) - """ + If ``input`` is a list of :class:`~pina.graph.Graph` or + :class:`~torch_geometric.data.Data`, all elements in + the list must share the same structure, with matching keys and + consistent data types. + """ super().__init__() self.input = input self.conditional_variables = conditional_variables @@ -82,13 +105,15 @@ def __init__(self, input, conditional_variables=None): class TensorDataCondition(DataCondition): """ - DataCondition for :class:`torch.Tensor` or - :class:`~pina.label_tensor.LabelTensor` input data + Specialization of the :class:`DataCondition` class for the case where + ``input`` is either a :class:`~pina.label_tensor.LabelTensor` object or a + :class:`torch.Tensor` object. """ class GraphDataCondition(DataCondition): """ - DataCondition for :class:`~pina.graph.Graph` or - :class:`~torch_geometric.data.Data` input data + Specialization of the :class:`DataCondition` class for the case where + ``input`` is either a :class:`~pina.graph.Graph` object or a + :class:`~torch_geometric.data.Data` object. """ diff --git a/pina/condition/domain_equation_condition.py b/pina/condition/domain_equation_condition.py index ee2b5074e..3565c0b41 100644 --- a/pina/condition/domain_equation_condition.py +++ b/pina/condition/domain_equation_condition.py @@ -8,31 +8,57 @@ class DomainEquationCondition(ConditionInterface): """ - Condition defined by a domain and an equation. It can be used in Physics - Informed problems. Before using this condition, make sure that input data - are correctly sampled from the domain. + The class :class:`DomainEquationCondition` defines a condition based on a + ``domain`` and an ``equation``. This condition is typically used in + physics-informed problems, where the model is trained to satisfy a given + ``equation`` over a specified ``domain``. The ``domain`` is used to sample + points where the ``equation`` residual is evaluated and minimized during + training. + + :Example: + + >>> from pina.domain import CartesianDomain + >>> from pina.equation import Equation + >>> from pina import Condition + + >>> # Equation to be satisfied over the domain: # x^2 + y^2 - 1 = 0 + >>> def dummy_equation(pts): + ... return pts["x"]**2 + pts["y"]**2 - 1 + + >>> domain = CartesianDomain({"x": [0, 1], "y": [0, 1]}) + >>> condition = Condition(domain=domain, equation=Equation(dummy_equation)) """ + # Available slots __slots__ = ["domain", "equation"] def __init__(self, domain, equation): """ - Initialise the object by storing the domain and equation. + Initialization of the :class:`DomainEquationCondition` class. - :param DomainInterface domain: Domain object containing the domain data. - :param EquationInterface equation: Equation object containing the - equation data. + :param DomainInterface domain: The domain over which the equation is + defined. + :param EquationInterface equation: The equation to be satisfied over the + specified domain. """ super().__init__() self.domain = domain self.equation = equation def __setattr__(self, key, value): + """ + Set the attribute value with type checking. + + :param str key: The attribute name. + :param any value: The value to set for the attribute. + """ if key == "domain": check_consistency(value, (DomainInterface, str)) DomainEquationCondition.__dict__[key].__set__(self, value) + elif key == "equation": check_consistency(value, (EquationInterface)) DomainEquationCondition.__dict__[key].__set__(self, value) + elif key in ("_problem"): super().__setattr__(key, value) diff --git a/pina/condition/input_equation_condition.py b/pina/condition/input_equation_condition.py index a803a8815..d32597894 100644 --- a/pina/condition/input_equation_condition.py +++ b/pina/condition/input_equation_condition.py @@ -1,6 +1,5 @@ """Module for the InputEquationCondition class and its subclasses.""" -from torch_geometric.data import Data from .condition_interface import ConditionInterface from ..label_tensor import LabelTensor from ..graph import Graph @@ -10,16 +9,38 @@ class InputEquationCondition(ConditionInterface): """ - Condition defined by input data and an equation. This condition can be - used in a Physics Informed problems. Based on the type of the input, - different condition implementations are available: - - - :class:`InputTensorEquationCondition`: For \ - :class:`~pina.label_tensor.LabelTensor` input data. - - :class:`InputGraphEquationCondition`: For :class:`~pina.graph.Graph` \ - input data. + The class :class:`InputEquationCondition` defines a condition based on + ``input`` data and an ``equation``. This condition is typically used in + physics-informed problems, where the model is trained to satisfy a given + ``equation`` through the evaluation of the residual performed at the + provided ``input``. + + The class automatically selects the appropriate implementation based on + the type of the ``input`` data. Depending on whether the ``input`` is a + tensor or graph-based data, one of the following specialized subclasses is + instantiated: + + - :class:`InputTensorEquationCondition`: For cases where the ``input`` + data is a :class:`~pina.label_tensor.LabelTensor` object. + + - :class:`InputGraphEquationCondition`: For cases where the ``input`` data + is a :class:`~pina.graph.Graph` object. + + :Example: + + >>> from pina import Condition, LabelTensor + >>> from pina.equation import Equation + >>> import torch + + >>> # Equation to be satisfied over the input points: # x^2 + y^2 - 1 = 0 + >>> def dummy_equation(pts): + ... return pts["x"]**2 + pts["y"]**2 - 1 + + >>> pts = LabelTensor(torch.randn(100, 2), labels=["x", "y"]) + >>> condition = Condition(input=pts, equation=Equation(dummy_equation)) """ + # Available input data types __slots__ = ["input", "equation"] _avail_input_cls = (LabelTensor, Graph, list, tuple) _avail_equation_cls = EquationInterface @@ -27,31 +48,31 @@ class InputEquationCondition(ConditionInterface): def __new__(cls, input, equation): """ Instantiate the appropriate subclass of :class:`InputEquationCondition` - based on the type of ``input``. + based on the type of ``input`` data. - :param input: Input data for the condition. + :param input: The input data for the condition. :type input: LabelTensor | Graph | list[Graph] | tuple[Graph] - :param EquationInterface equation: Equation object containing the - equation function. - :return: Subclass of InputEquationCondition, based on the input type. + :param EquationInterface equation: The equation to be satisfied over the + specified ``input`` data. + :return: The subclass of InputEquationCondition. :rtype: pina.condition.input_equation_condition. InputTensorEquationCondition | pina.condition.input_equation_condition.InputGraphEquationCondition - :raises ValueError: If input is not of type - :class:`~pina.label_tensor.LabelTensor`, :class:`~pina.graph.Graph`. + :raises ValueError: If input is not of type :class:`~pina.graph.Graph` + or :class:`~pina.label_tensor.LabelTensor`. """ - - # If the class is already a subclass, return the instance if cls != InputEquationCondition: return super().__new__(cls) - # Instanciate the correct subclass - if isinstance(input, (Graph, Data, list, tuple)): + # If the input is a Graph object + if isinstance(input, (Graph, list, tuple)): subclass = InputGraphEquationCondition cls._check_graph_list_consistency(input) subclass._check_label_tensor(input) return subclass.__new__(subclass, input, equation) + + # If the input is a LabelTensor if isinstance(input, LabelTensor): subclass = InputTensorEquationCondition return subclass.__new__(subclass, input, equation) @@ -63,69 +84,74 @@ def __new__(cls, input, equation): def __init__(self, input, equation): """ - Initialize the object by storing the input data and equation object. + Initialization of the :class:`InputEquationCondition` class. - :param input: Input data for the condition. - :type input: LabelTensor | Graph | - list[Graph] | tuple[Graph] - :param EquationInterface equation: Equation object containing the - equation function. + :param input: The input data for the condition. + :type input: LabelTensor | Graph | list[Graph] | tuple[Graph] + :param EquationInterface equation: The equation to be satisfied over the + specified input points. .. note:: - If ``input`` consists of a list of :class:`~pina.graph.Graph` or - :class:`~torch_geometric.data.Data`, all elements must have the same - structure (keys and data types) - """ + If ``input`` is a list of :class:`~pina.graph.Graph` all elements in + the list must share the same structure, with matching keys and + consistent data types. + """ super().__init__() self.input = input self.equation = equation def __setattr__(self, key, value): + """ + Set the attribute value with type checking. + + :param str key: The attribute name. + :param any value: The value to set for the attribute. + """ if key == "input": check_consistency(value, self._avail_input_cls) InputEquationCondition.__dict__[key].__set__(self, value) + elif key == "equation": check_consistency(value, self._avail_equation_cls) InputEquationCondition.__dict__[key].__set__(self, value) + elif key in ("_problem"): super().__setattr__(key, value) class InputTensorEquationCondition(InputEquationCondition): """ - InputEquationCondition subclass for :class:`~pina.label_tensor.LabelTensor` - input data. + Specialization of the :class:`InputEquationCondition` class for the case + where ``input`` is a :class:`~pina.label_tensor.LabelTensor` object. """ class InputGraphEquationCondition(InputEquationCondition): """ - InputEquationCondition subclass for :class:`~pina.graph.Graph` input data. + Specialization of the :class:`InputEquationCondition` class for the case + where ``input`` is a :class:`~pina.graph.Graph` object. """ @staticmethod def _check_label_tensor(input): """ Check if at least one :class:`~pina.label_tensor.LabelTensor` is present - in the :class:`~pina.graph.Graph` object. - - :param input: Input data. - :type input: torch.Tensor | Graph | Data + in the ``input`` object. + :param input: The input data. + :type input: torch.Tensor | Graph | list[Graph] | tuple[Graph] :raises ValueError: If the input data object does not contain at least one LabelTensor. """ - # Store the fist element of the list/tuple if input is a list/tuple - # it is anougth to check the first element because all elements must - # have the same type and structure (already checked) + # Store the first element: it is sufficient to check this since all + # elements must have the same type and structure (already checked). data = input[0] if isinstance(input, (list, tuple)) else input # Check if the input data contains at least one LabelTensor for v in data.values(): if isinstance(v, LabelTensor): return - raise ValueError( - "The input data object must contain at least one LabelTensor." - ) + + raise ValueError("The input must contain at least one LabelTensor.") diff --git a/pina/condition/input_target_condition.py b/pina/condition/input_target_condition.py index d39fb28ca..07b07bb7b 100644 --- a/pina/condition/input_target_condition.py +++ b/pina/condition/input_target_condition.py @@ -11,39 +11,66 @@ class InputTargetCondition(ConditionInterface): """ - Condition defined by input and target data. This condition can be used in - both supervised learning and Physics-informed problems. Based on the type of - the input and target, different condition implementations are available: - - - :class:`TensorInputTensorTargetCondition`: For :class:`torch.Tensor` or \ - :class:`~pina.label_tensor.LabelTensor` input and target data. - - :class:`TensorInputGraphTargetCondition`: For :class:`torch.Tensor` or \ - :class:`~pina.label_tensor.LabelTensor` input and \ - :class:`~pina.graph.Graph` or :class:`torch_geometric.data.Data` \ - target data. - - :class:`GraphInputTensorTargetCondition`: For :class:`~pina.graph.Graph` \ - or :class:`~torch_geometric.data.Data` input and :class:`torch.Tensor` \ - or :class:`~pina.label_tensor.LabelTensor` target data. - - :class:`GraphInputGraphTargetCondition`: For :class:`~pina.graph.Graph` \ - or :class:`~torch_geometric.data.Data` input and target data. + The :class:`InputTargetCondition` class represents a supervised condition + defined by both ``input`` and ``target`` data. The model is trained to + reproduce the ``target`` values given the ``input``. Supported data types + include :class:`torch.Tensor`, :class:`~pina.label_tensor.LabelTensor`, + :class:`~pina.graph.Graph`, or :class:`~torch_geometric.data.Data`. + + The class automatically selects the appropriate implementation based on + the types of ``input`` and ``target``. Depending on whether the ``input`` + and ``target`` are tensors or graph-based data, one of the following + specialized subclasses is instantiated: + + - :class:`TensorInputTensorTargetCondition`: For cases where both ``input`` + and ``target`` data are either :class:`torch.Tensor` or + :class:`~pina.label_tensor.LabelTensor`. + + - :class:`TensorInputGraphTargetCondition`: For cases where ``input`` is + either a :class:`torch.Tensor` or :class:`~pina.label_tensor.LabelTensor` + and ``target`` is either a :class:`~pina.graph.Graph` or a + :class:`torch_geometric.data.Data`. + + - :class:`GraphInputTensorTargetCondition`: For cases where ``input`` is + either a :class:`~pina.graph.Graph` or :class:`torch_geometric.data.Data` + and ``target`` is either a :class:`torch.Tensor` or a + :class:`~pina.label_tensor.LabelTensor`. + + - :class:`GraphInputGraphTargetCondition`: For cases where both ``input`` + and ``target`` are either :class:`~pina.graph.Graph` or + :class:`torch_geometric.data.Data`. + + :Example: + + >>> from pina import Condition, LabelTensor + >>> from pina.graph import Graph + >>> import torch + + >>> pos = LabelTensor(torch.randn(100, 2), labels=["x", "y"]) + >>> edge_index = torch.randint(0, 100, (2, 300)) + >>> graph = Graph(pos=pos, edge_index=edge_index) + + >>> input = LabelTensor(torch.randn(100, 2), labels=["x", "y"]) + >>> condition = Condition(input=input, target=graph) """ + # Available input and target data types __slots__ = ["input", "target"] _avail_input_cls = (torch.Tensor, LabelTensor, Data, Graph, list, tuple) _avail_output_cls = (torch.Tensor, LabelTensor, Data, Graph, list, tuple) def __new__(cls, input, target): """ - Instantiate the appropriate subclass of InputTargetCondition based on - the types of input and target data. + Instantiate the appropriate subclass of :class:`InputTargetCondition` + based on the types of both ``input`` and ``target`` data. - :param input: Input data for the condition. + :param input: The input data for the condition. :type input: torch.Tensor | LabelTensor | Graph | Data | list[Graph] | list[Data] | tuple[Graph] | tuple[Data] - :param target: Target data for the condition. + :param target: The target data for the condition. :type target: torch.Tensor | LabelTensor | Graph | Data | list[Graph] | list[Data] | tuple[Graph] | tuple[Data] - :return: Subclass of InputTargetCondition + :return: The subclass of InputTargetCondition. :rtype: pina.condition.input_target_condition. TensorInputTensorTargetCondition | pina.condition.input_target_condition. @@ -59,11 +86,14 @@ def __new__(cls, input, target): if cls != InputTargetCondition: return super().__new__(cls) + # Tensor - Tensor if isinstance(input, (torch.Tensor, LabelTensor)) and isinstance( target, (torch.Tensor, LabelTensor) ): subclass = TensorInputTensorTargetCondition return subclass.__new__(subclass, input, target) + + # Tensor - Graph if isinstance(input, (torch.Tensor, LabelTensor)) and isinstance( target, (Graph, Data, list, tuple) ): @@ -71,6 +101,7 @@ def __new__(cls, input, target): subclass = TensorInputGraphTargetCondition return subclass.__new__(subclass, input, target) + # Graph - Tensor if isinstance(input, (Graph, Data, list, tuple)) and isinstance( target, (torch.Tensor, LabelTensor) ): @@ -78,6 +109,7 @@ def __new__(cls, input, target): subclass = GraphInputTensorTargetCondition return subclass.__new__(subclass, input, target) + # Graph - Graph if isinstance(input, (Graph, Data, list, tuple)) and isinstance( target, (Graph, Data, list, tuple) ): @@ -86,30 +118,31 @@ def __new__(cls, input, target): subclass = GraphInputGraphTargetCondition return subclass.__new__(subclass, input, target) + # If the input and/or target are not of the correct type raise an error raise ValueError( - "Invalid input/target types. " + "Invalid input | target types." "Please provide either torch_geometric.data.Data, Graph, " "LabelTensor or torch.Tensor objects." ) def __init__(self, input, target): """ - Initialize the object by storing the ``input`` and ``target`` data. + Initialization of the :class:`InputTargetCondition` class. - :param input: Input data for the condition. + :param input: The input data for the condition. :type input: torch.Tensor | LabelTensor | Graph | Data | list[Graph] | list[Data] | tuple[Graph] | tuple[Data] - :param target: Target data for the condition. + :param target: The target data for the condition. :type target: torch.Tensor | LabelTensor | Graph | Data | list[Graph] | list[Data] | tuple[Graph] | tuple[Data] .. note:: - If either input or target consists of a list of - :class:~pina.graph.Graph or :class:~torch_geometric.data.Data - objects, all elements must have the same structure (matching - keys and data types). - """ + If either ``input`` or ``target`` is a list of + :class:`~pina.graph.Graph` or :class:`~torch_geometric.data.Data` + objects, all elements in the list must share the same structure, + with matching keys and consistent data types. + """ super().__init__() self._check_input_target_len(input, target) self.input = input @@ -117,10 +150,24 @@ def __init__(self, input, target): @staticmethod def _check_input_target_len(input, target): + """ + Check that the length of the input and target lists are the same. + + :param input: The input data. + :type input: torch.Tensor | LabelTensor | Graph | Data | list[Graph] | + list[Data] | tuple[Graph] | tuple[Data] + :param target: The target data. + :type target: torch.Tensor | LabelTensor | Graph | Data | list[Graph] | + list[Data] | tuple[Graph] | tuple[Data] + :raises ValueError: If the lengths of the input and target lists do not + match. + """ if isinstance(input, (Graph, Data)) or isinstance( target, (Graph, Data) ): return + + # Raise an error if the lengths of the input and target do not match if len(input) != len(target): raise ValueError( "The input and target lists must have the same length." @@ -129,30 +176,33 @@ def _check_input_target_len(input, target): class TensorInputTensorTargetCondition(InputTargetCondition): """ - InputTargetCondition subclass for :class:`torch.Tensor` or - :class:`~pina.label_tensor.LabelTensor` ``input`` and ``target`` data. + Specialization of the :class:`InputTargetCondition` class for the case where + both ``input`` and ``target`` are :class:`torch.Tensor` or + :class:`~pina.label_tensor.LabelTensor` objects. """ class TensorInputGraphTargetCondition(InputTargetCondition): """ - InputTargetCondition subclass for :class:`torch.Tensor` or - :class:`~pina.label_tensor.LabelTensor` ``input`` and - :class:`~pina.graph.Graph` or :class:`~torch_geometric.data.Data` `target` - data. + Specialization of the :class:`InputTargetCondition` class for the case where + ``input`` is either a :class:`torch.Tensor` or a + :class:`~pina.label_tensor.LabelTensor` object and ``target`` is either a + :class:`~pina.graph.Graph` or a :class:`torch_geometric.data.Data` object. """ class GraphInputTensorTargetCondition(InputTargetCondition): """ - InputTargetCondition subclass for :class:`~pina.graph.Graph` o - :class:`~torch_geometric.data.Data` ``input`` and :class:`torch.Tensor` or - :class:`~pina.label_tensor.LabelTensor` ``target`` data. + Specialization of the :class:`InputTargetCondition` class for the case where + ``input`` is either a :class:`~pina.graph.Graph` or + :class:`torch_geometric.data.Data` object and ``target`` is either a + :class:`torch.Tensor` or a :class:`~pina.label_tensor.LabelTensor` object. """ class GraphInputGraphTargetCondition(InputTargetCondition): """ - InputTargetCondition subclass for :class:`~pina.graph.Graph`/ - :class:`~torch_geometric.data.Data` ``input`` and ``target`` data. + Specialization of the :class:`InputTargetCondition` class for the case where + both ``input`` and ``target`` are either :class:`~pina.graph.Graph` or + :class:`torch_geometric.data.Data` objects. """ diff --git a/pina/data/dataset.py b/pina/data/dataset.py index 386c3c53c..62e3913d8 100644 --- a/pina/data/dataset.py +++ b/pina/data/dataset.py @@ -276,20 +276,6 @@ def _create_graph_batch(self, data): batch = LabelBatch.from_data_list(data) return batch - def _create_tensor_batch(self, data): - """ - Reshape properly ``data`` tensor to be processed handle by the graph - based models. - - :param data: torch.Tensor object of shape ``(N, ...)`` where ``N`` is - the number of data objects. - :type data: torch.Tensor | LabelTensor - :return: Reshaped tensor object. - :rtype: torch.Tensor | LabelTensor - """ - out = data.reshape(-1, *data.shape[2:]) - return out - def create_batch(self, data): """ Create a Batch object from a list of :class:`~torch_geometric.data.Data` @@ -324,7 +310,7 @@ def _retrive_data(self, data, idx_list): k: ( self._create_graph_batch([v[i] for i in idx_list]) if isinstance(v, list) - else self._create_tensor_batch(v[idx_list]) + else v[idx_list] ) for k, v in data.items() } diff --git a/pina/equation/__init__.py b/pina/equation/__init__.py index 07ab74239..afe60a9e6 100644 --- a/pina/equation/__init__.py +++ b/pina/equation/__init__.py @@ -6,9 +6,26 @@ "FixedValue", "FixedGradient", "FixedFlux", + "FixedLaplacian", "Laplace", + "Advection", + "AllenCahn", + "DiffusionReaction", + "Helmholtz", + "Poisson", ] from .equation import Equation -from .equation_factory import FixedFlux, FixedGradient, Laplace, FixedValue +from .equation_factory import ( + FixedFlux, + FixedGradient, + FixedLaplacian, + FixedValue, + Laplace, + Advection, + AllenCahn, + DiffusionReaction, + Helmholtz, + Poisson, +) from .system_equation import SystemEquation diff --git a/pina/equation/equation.py b/pina/equation/equation.py index 60b538e11..1e4622db6 100644 --- a/pina/equation/equation.py +++ b/pina/equation/equation.py @@ -1,5 +1,7 @@ """Module for the Equation.""" +import inspect + from .equation_interface import EquationInterface @@ -25,6 +27,9 @@ def __init__(self, equation): "Expected a callable function, got " f"{equation}" ) + # compute the signature + sig = inspect.signature(equation) + self.__len_sig = len(sig.parameters) self.__equation = equation def residual(self, input_, output_, params_=None): @@ -41,9 +46,14 @@ def residual(self, input_, output_, params_=None): parameters must be initialized to ``None``. Default is ``None``. :return: The computed residual of the equation. :rtype: LabelTensor + :raises RuntimeError: If the underlying equation signature length is not + 2 (direct problem) or 3 (inverse problem). """ - if params_ is None: - result = self.__equation(input_, output_) - else: - result = self.__equation(input_, output_, params_) - return result + if self.__len_sig == 2: + return self.__equation(input_, output_) + if self.__len_sig == 3: + return self.__equation(input_, output_, params_) + raise RuntimeError( + f"Unexpected number of arguments in equation: {self.__len_sig}. " + "Expected either 2 (direct problem) or 3 (inverse problem)." + ) diff --git a/pina/equation/equation_factory.py b/pina/equation/equation_factory.py index 879990ae9..057ea65d4 100644 --- a/pina/equation/equation_factory.py +++ b/pina/equation/equation_factory.py @@ -1,10 +1,16 @@ """Module for defining various general equations.""" +from typing import Callable +import torch from .equation import Equation from ..operator import grad, div, laplacian +from ..utils import check_consistency +# Pylint warning disabled because the classes defined in this module +# inherit from Equation and are meant to be simple containers for equations. -class FixedValue(Equation): + +class FixedValue(Equation): # pylint: disable=R0903 """ Equation to enforce a fixed value. Can be used to enforce Dirichlet Boundary conditions. @@ -21,7 +27,7 @@ def __init__(self, value, components=None): Default is ``None``. """ - def equation(input_, output_): + def equation(_, output_): """ Definition of the equation to enforce a fixed value. @@ -39,7 +45,7 @@ def equation(input_, output_): super().__init__(equation) -class FixedGradient(Equation): +class FixedGradient(Equation): # pylint: disable=R0903 """ Equation to enforce a fixed gradient for a specific condition. """ @@ -75,7 +81,7 @@ def equation(input_, output_): super().__init__(equation) -class FixedFlux(Equation): +class FixedFlux(Equation): # pylint: disable=R0903 """ Equation to enforce a fixed flux, or divergence, for a specific condition. """ @@ -110,17 +116,18 @@ def equation(input_, output_): super().__init__(equation) -class Laplace(Equation): +class FixedLaplacian(Equation): # pylint: disable=R0903 """ - Equation to enforce a null laplacian for a specific condition. + Equation to enforce a fixed laplacian for a specific condition. """ - def __init__(self, components=None, d=None): + def __init__(self, value, components=None, d=None): """ - Initialization of the :class:`Laplace` class. + Initialization of the :class:`FixedLaplacian` class. + :param float value: The fixed value to be enforced to the laplacian. :param list[str] components: The name of the output variables for which - the null laplace condition is applied. It should be a subset of the + the fixed laplace condition is applied. It should be a subset of the output labels. If ``None``, all output variables are considered. Default is ``None``. :param list[str] d: The name of the input variables on which the @@ -131,7 +138,7 @@ def __init__(self, components=None, d=None): def equation(input_, output_): """ - Definition of the equation to enforce a null laplacian. + Definition of the equation to enforce a fixed laplacian. :param LabelTensor input_: Input points where the equation is evaluated. @@ -140,6 +147,308 @@ def equation(input_, output_): :return: The computed residual of the equation. :rtype: LabelTensor """ - return laplacian(output_, input_, components=components, d=d) + return ( + laplacian(output_, input_, components=components, d=d) - value + ) + + super().__init__(equation) + + +class Laplace(FixedLaplacian): # pylint: disable=R0903 + r""" + Equation to enforce a null laplacian for a specific condition. + The equation is defined as follows: + + .. math:: + + \delta u = 0 + + """ + + def __init__(self, components=None, d=None): + """ + Initialization of the :class:`Laplace` class. + + :param list[str] components: The name of the output variables for which + the null laplace condition is applied. It should be a subset of the + output labels. If ``None``, all output variables are considered. + Default is ``None``. + :param list[str] d: The name of the input variables on which the + laplacian is computed. It should be a subset of the input labels. + If ``None``, all the input variables are considered. + Default is ``None``. + """ + super().__init__(0.0, components=components, d=d) + + +class Advection(Equation): # pylint: disable=R0903 + r""" + Implementation of the N-dimensional advection equation with constant + velocity parameter. The equation is defined as follows: + + .. math:: + + \frac{\partial u}{\partial t} + c \cdot \nabla u = 0 + + Here, :math:`c` is the advection velocity parameter. + """ + + def __init__(self, c): + """ + Initialization of the :class:`Advection` class. + + :param c: The advection velocity. If a scalar is provided, the same + velocity is applied to all spatial dimensions. If a list is + provided, it must contain one value per spatial dimension. + :type c: float | int | List[float] | List[int] + :raises ValueError: If ``c`` is an empty list. + """ + # Check consistency + check_consistency(c, (float, int, list)) + if isinstance(c, list): + all(check_consistency(ci, (float, int)) for ci in c) + if len(c) < 1: + raise ValueError("'c' cannot be an empty list.") + else: + c = [c] + + # Store advection velocity parameter + self.c = torch.tensor(c).unsqueeze(0) + + def equation(input_, output_): + """ + Implementation of the advection equation. + + :param LabelTensor input_: The input data of the problem. + :param LabelTensor output_: The output data of the problem. + :return: The residual of the advection equation. + :rtype: LabelTensor + :raises ValueError: If the ``input_`` labels do not contain the time + variable 't'. + :raises ValueError: If ``c`` is a list and its length is not + consistent with the number of spatial dimensions. + """ + # Store labels + input_lbl = input_.labels + spatial_d = [di for di in input_lbl if di != "t"] + + # Ensure time is passed as input + if "t" not in input_lbl: + raise ValueError( + "The ``input_`` labels must contain the time 't' variable." + ) + + # Ensure consistency of c length + if len(self.c) != (len(input_lbl) - 1) and len(self.c) > 1: + raise ValueError( + "If 'c' is passed as a list, its length must be equal to " + "the number of spatial dimensions." + ) + + # Repeat c to ensure consistent shape for advection + self.c = self.c.repeat(output_.shape[0], 1) + if self.c.shape[1] != (len(input_lbl) - 1): + self.c = self.c.repeat(1, len(input_lbl) - 1) + + # Add a dimension to c for the following operations + self.c = self.c.unsqueeze(-1) + + # Compute the time derivative and the spatial gradient + time_der = grad(output_, input_, components=None, d="t") + grads = grad(output_=output_, input_=input_, d=spatial_d) + + # Reshape and transpose + tmp = grads.reshape(*output_.shape, len(spatial_d)) + tmp = tmp.transpose(-1, -2) + + # Compute advection term + adv = (tmp * self.c).sum(dim=tmp.tensor.ndim - 2) + + return time_der + adv + + super().__init__(equation) + + +class AllenCahn(Equation): # pylint: disable=R0903 + r""" + Implementation of the N-dimensional Allen-Cahn equation, defined as follows: + + .. math:: + + \frac{\partial u}{\partial t} - \alpha \Delta u + \beta(u^3 - u) = 0 + + Here, :math:`\alpha` and :math:`\beta` are parameters of the equation. + """ + + def __init__(self, alpha, beta): + """ + Initialization of the :class:`AllenCahn` class. + + :param alpha: The diffusion coefficient. + :type alpha: float | int + :param beta: The reaction coefficient. + :type beta: float | int + """ + check_consistency(alpha, (float, int)) + check_consistency(beta, (float, int)) + self.alpha = alpha + self.beta = beta + + def equation(input_, output_): + """ + Implementation of the Allen-Cahn equation. + + :param LabelTensor input_: The input data of the problem. + :param LabelTensor output_: The output data of the problem. + :return: The residual of the Allen-Cahn equation. + :rtype: LabelTensor + :raises ValueError: If the ``input_`` labels do not contain the time + variable 't'. + """ + # Ensure time is passed as input + if "t" not in input_.labels: + raise ValueError( + "The ``input_`` labels must contain the time 't' variable." + ) + + # Compute the time derivative and the spatial laplacian + u_t = grad(output_, input_, d=["t"]) + u_xx = laplacian( + output_, input_, d=[di for di in input_.labels if di != "t"] + ) + + return u_t - self.alpha * u_xx + self.beta * (output_**3 - output_) + + super().__init__(equation) + + +class DiffusionReaction(Equation): # pylint: disable=R0903 + r""" + Implementation of the N-dimensional Diffusion-Reaction equation, + defined as follows: + + .. math:: + + \frac{\partial u}{\partial t} - \alpha \Delta u - f = 0 + + Here, :math:`\alpha` is a parameter of the equation, while :math:`f` is the + reaction term. + """ + + def __init__(self, alpha, forcing_term): + """ + Initialization of the :class:`DiffusionReaction` class. + + :param alpha: The diffusion coefficient. + :type alpha: float | int + :param Callable forcing_term: The forcing field function, taking as + input the points on which evaluation is required. + """ + check_consistency(alpha, (float, int)) + check_consistency(forcing_term, (Callable)) + self.alpha = alpha + self.forcing_term = forcing_term + + def equation(input_, output_): + """ + Implementation of the Diffusion-Reaction equation. + + :param LabelTensor input_: The input data of the problem. + :param LabelTensor output_: The output data of the problem. + :return: The residual of the Diffusion-Reaction equation. + :rtype: LabelTensor + :raises ValueError: If the ``input_`` labels do not contain the time + variable 't'. + """ + # Ensure time is passed as input + if "t" not in input_.labels: + raise ValueError( + "The ``input_`` labels must contain the time 't' variable." + ) + + # Compute the time derivative and the spatial laplacian + u_t = grad(output_, input_, d=["t"]) + u_xx = laplacian( + output_, input_, d=[di for di in input_.labels if di != "t"] + ) + + return u_t - self.alpha * u_xx - self.forcing_term(input_) + + super().__init__(equation) + + +class Helmholtz(Equation): # pylint: disable=R0903 + r""" + Implementation of the Helmholtz equation, defined as follows: + + .. math:: + + \Delta u + k u - f = 0 + + Here, :math:`k` is a parameter of the equation, while :math:`f` is the + forcing term. + """ + + def __init__(self, k, forcing_term): + """ + Initialization of the :class:`Helmholtz` class. + + :param k: The parameter of the equation. + :type k: float | int + :param Callable forcing_term: The forcing field function, taking as + input the points on which evaluation is required. + """ + check_consistency(k, (int, float)) + check_consistency(forcing_term, (Callable)) + self.k = k + self.forcing_term = forcing_term + + def equation(input_, output_): + """ + Implementation of the Helmholtz equation. + + :param LabelTensor input_: The input data of the problem. + :param LabelTensor output_: The output data of the problem. + :return: The residual of the Helmholtz equation. + :rtype: LabelTensor + """ + lap = laplacian(output_, input_) + return lap + self.k * output_ - self.forcing_term(input_) + + super().__init__(equation) + + +class Poisson(Equation): # pylint: disable=R0903 + r""" + Implementation of the Poisson equation, defined as follows: + + .. math:: + + \Delta u - f = 0 + + Here, :math:`f` is the forcing term. + """ + + def __init__(self, forcing_term): + """ + Initialization of the :class:`Poisson` class. + + :param Callable forcing_term: The forcing field function, taking as + input the points on which evaluation is required. + """ + check_consistency(forcing_term, (Callable)) + self.forcing_term = forcing_term + + def equation(input_, output_): + """ + Implementation of the Poisson equation. + + :param LabelTensor input_: The input data of the problem. + :param LabelTensor output_: The output data of the problem. + :return: The residual of the Poisson equation. + :rtype: LabelTensor + """ + lap = laplacian(output_, input_) + return lap - self.forcing_term(input_) super().__init__(equation) diff --git a/pina/geometry/__init__.py b/pina/geometry/__init__.py deleted file mode 100644 index 762820ac6..000000000 --- a/pina/geometry/__init__.py +++ /dev/null @@ -1,20 +0,0 @@ -"""Old module for geometry classes and functions. Deprecated in 0.2.0.""" - -import warnings - -from ..domain import * -from ..utils import custom_warning_format - -# back-compatibility 0.1 -# creating alias -Location = DomainInterface - -# Set the custom format for warnings -warnings.formatwarning = custom_warning_format -warnings.filterwarnings("always", category=DeprecationWarning) -warnings.warn( - "'pina.geometry' is deprecated and will be removed " - "in future versions. Please use 'pina.domain' instead. " - "Location moved to DomainInferface object.", - DeprecationWarning, -) diff --git a/pina/loss/__init__.py b/pina/loss/__init__.py index 2f15c6db9..d91cf7ab0 100644 --- a/pina/loss/__init__.py +++ b/pina/loss/__init__.py @@ -7,6 +7,8 @@ "WeightingInterface", "ScalarWeighting", "NeuralTangentKernelWeighting", + "SelfAdaptiveWeighting", + "LinearWeighting", ] from .loss_interface import LossInterface @@ -15,3 +17,5 @@ from .weighting_interface import WeightingInterface from .scalar_weighting import ScalarWeighting from .ntk_weighting import NeuralTangentKernelWeighting +from .self_adaptive_weighting import SelfAdaptiveWeighting +from .linear_weighting import LinearWeighting diff --git a/pina/loss/linear_weighting.py b/pina/loss/linear_weighting.py new file mode 100644 index 000000000..9049b52fa --- /dev/null +++ b/pina/loss/linear_weighting.py @@ -0,0 +1,64 @@ +"""Module for the LinearWeighting class.""" + +from ..loss import WeightingInterface +from ..utils import check_consistency, check_positive_integer + + +class LinearWeighting(WeightingInterface): + """ + A weighting scheme that linearly scales weights from initial values to final + values over a specified number of epochs. + """ + + def __init__(self, initial_weights, final_weights, target_epoch): + """ + :param dict initial_weights: The weights to be assigned to each loss + term at the beginning of training. The keys are the conditions and + the values are the corresponding weights. If a condition is not + present in the dictionary, the default value (1) is used. + :param dict final_weights: The weights to be assigned to each loss term + once the target epoch is reached. The keys are the conditions and + the values are the corresponding weights. If a condition is not + present in the dictionary, the default value (1) is used. + :param int target_epoch: The epoch at which the weights reach their + final values. + :raises ValueError: If the keys of the two dictionaries are not + consistent. + """ + super().__init__(update_every_n_epochs=1, aggregator="sum") + + # Check consistency + check_consistency([initial_weights, final_weights], dict) + check_positive_integer(value=target_epoch, strict=True) + + # Check that the keys of the two dictionaries are the same + if initial_weights.keys() != final_weights.keys(): + raise ValueError( + "The keys of the initial_weights and final_weights " + "dictionaries must be the same." + ) + + # Initialization + self.initial_weights = initial_weights + self.final_weights = final_weights + self.target_epoch = target_epoch + + def weights_update(self, losses): + """ + Update the weighting scheme based on the given losses. + + :param dict losses: The dictionary of losses. + :return: The updated weights. + :rtype: dict + """ + return { + condition: self.last_saved_weights().get( + condition, self.initial_weights.get(condition, 1) + ) + + ( + self.final_weights.get(condition, 1) + - self.initial_weights.get(condition, 1) + ) + / (self.target_epoch) + for condition in losses.keys() + } diff --git a/pina/loss/ntk_weighting.py b/pina/loss/ntk_weighting.py index d8c947f06..fe671157a 100644 --- a/pina/loss/ntk_weighting.py +++ b/pina/loss/ntk_weighting.py @@ -1,9 +1,8 @@ """Module for Neural Tangent Kernel Class""" import torch -from torch.nn import Module from .weighting_interface import WeightingInterface -from ..utils import check_consistency +from ..utils import check_consistency, in_range class NeuralTangentKernelWeighting(WeightingInterface): @@ -21,51 +20,51 @@ class NeuralTangentKernelWeighting(WeightingInterface): """ - def __init__(self, model, alpha=0.5): + def __init__(self, update_every_n_epochs=1, alpha=0.5): """ Initialization of the :class:`NeuralTangentKernelWeighting` class. - :param torch.nn.Module model: The neural network model. + :param int update_every_n_epochs: The number of training epochs between + weight updates. If set to 1, the weights are updated at every epoch. + Default is 1. :param float alpha: The alpha parameter. - :raises ValueError: If ``alpha`` is not between 0 and 1 (inclusive). """ + super().__init__(update_every_n_epochs=update_every_n_epochs) - super().__init__() + # Check consistency check_consistency(alpha, float) - check_consistency(model, Module) - if alpha < 0 or alpha > 1: - raise ValueError("alpha should be a value between 0 and 1") + if not in_range(alpha, [0, 1], strict=False): + raise ValueError("alpha must be in range (0, 1).") + + # Initialize parameters self.alpha = alpha - self.model = model self.weights = {} - self.default_value_weights = 1 - def aggregate(self, losses): + def weights_update(self, losses): """ - Weight the losses according to the Neural Tangent Kernel - algorithm. + Update the weighting scheme based on the given losses. - :param dict(torch.Tensor) input: The dictionary of losses. - :return: The losses aggregation. It should be a scalar Tensor. - :rtype: torch.Tensor + :param dict losses: The dictionary of losses. + :return: The updated weights. + :rtype: dict """ + # Define a dictionary to store the norms of the gradients losses_norm = {} - for condition in losses: - losses[condition].backward(retain_graph=True) - grads = [] - for param in self.model.parameters(): - grads.append(param.grad.view(-1)) - grads = torch.cat(grads) - losses_norm[condition] = torch.norm(grads) - self.weights = { - condition: self.alpha - * self.weights.get(condition, self.default_value_weights) + + # Compute the gradient norms for each loss component + for condition, loss in losses.items(): + loss.backward(retain_graph=True) + grads = torch.cat( + [p.grad.flatten() for p in self.solver.model.parameters()] + ) + losses_norm[condition] = grads.norm() + + # Update the weights + return { + condition: self.alpha * self.last_saved_weights().get(condition, 1) + (1 - self.alpha) * losses_norm[condition] / sum(losses_norm.values()) for condition in losses } - return sum( - self.weights[condition] * loss for condition, loss in losses.items() - ) diff --git a/pina/loss/scalar_weighting.py b/pina/loss/scalar_weighting.py index 6bc093c7d..692c4937b 100644 --- a/pina/loss/scalar_weighting.py +++ b/pina/loss/scalar_weighting.py @@ -4,22 +4,6 @@ from ..utils import check_consistency -class _NoWeighting(WeightingInterface): - """ - Weighting scheme that does not apply any weighting to the losses. - """ - - def aggregate(self, losses): - """ - Aggregate the losses. - - :param dict losses: The dictionary of losses. - :return: The aggregated losses. - :rtype: torch.Tensor - """ - return sum(losses.values()) - - class ScalarWeighting(WeightingInterface): """ Weighting scheme that assigns a scalar weight to each loss term. @@ -33,27 +17,43 @@ def __init__(self, weights): If a single scalar value is provided, it is assigned to all loss terms. If a dictionary is provided, the keys are the conditions and the values are the weights. If a condition is not present in the - dictionary, the default value is used. + dictionary, the default value (1) is used. :type weights: float | int | dict """ - super().__init__() + super().__init__(update_every_n_epochs=1, aggregator="sum") + + # Check consistency check_consistency([weights], (float, dict, int)) - if isinstance(weights, (float, int)): - self.default_value_weights = weights - self.weights = {} - else: + + # Initialization + if isinstance(weights, dict): + self.values = weights self.default_value_weights = 1 - self.weights = weights + else: + self.values = {} + self.default_value_weights = weights - def aggregate(self, losses): + def weights_update(self, losses): """ - Aggregate the losses. + Update the weighting scheme based on the given losses. :param dict losses: The dictionary of losses. - :return: The aggregated losses. - :rtype: torch.Tensor + :return: The updated weights. + :rtype: dict + """ + return { + condition: self.values.get(condition, self.default_value_weights) + for condition in losses.keys() + } + + +class _NoWeighting(ScalarWeighting): + """ + Weighting scheme that does not apply any weighting to the losses. + """ + + def __init__(self): + """ + Initialization of the :class:`_NoWeighting` class. """ - return sum( - self.weights.get(condition, self.default_value_weights) * loss - for condition, loss in losses.items() - ) + super().__init__(weights=1) diff --git a/pina/loss/self_adaptive_weighting.py b/pina/loss/self_adaptive_weighting.py new file mode 100644 index 000000000..62196c529 --- /dev/null +++ b/pina/loss/self_adaptive_weighting.py @@ -0,0 +1,57 @@ +"""Module for Self-Adaptive Weighting class.""" + +import torch +from .weighting_interface import WeightingInterface + + +class SelfAdaptiveWeighting(WeightingInterface): + """ + A self-adaptive weighting scheme to tackle the imbalance among the loss + components. This formulation equalizes the gradient norms of the losses, + preventing bias toward any particular term during training. + + .. seealso:: + + **Original reference**: + Wang, S., Sankaran, S., Stinis., P., Perdikaris, P. (2025). + *Simulating Three-dimensional Turbulence with Physics-informed Neural + Networks*. + DOI: `arXiv preprint arXiv:2507.08972. + `_ + + """ + + def __init__(self, update_every_n_epochs=1): + """ + Initialization of the :class:`SelfAdaptiveWeighting` class. + + :param int update_every_n_epochs: The number of training epochs between + weight updates. If set to 1, the weights are updated at every epoch. + Default is 1. + """ + super().__init__(update_every_n_epochs=update_every_n_epochs) + + def weights_update(self, losses): + """ + Update the weighting scheme based on the given losses. + + :param dict losses: The dictionary of losses. + :return: The updated weights. + :rtype: dict + """ + # Define a dictionary to store the norms of the gradients + losses_norm = {} + + # Compute the gradient norms for each loss component + for condition, loss in losses.items(): + loss.backward(retain_graph=True) + grads = torch.cat( + [p.grad.flatten() for p in self.solver.model.parameters()] + ) + losses_norm[condition] = grads.norm() + + # Update the weights + return { + condition: sum(losses_norm.values()) / losses_norm[condition] + for condition in losses + } diff --git a/pina/loss/weighting_interface.py b/pina/loss/weighting_interface.py index 8b8cb2f28..bc34c3181 100644 --- a/pina/loss/weighting_interface.py +++ b/pina/loss/weighting_interface.py @@ -1,6 +1,10 @@ """Module for the Weighting Interface.""" from abc import ABCMeta, abstractmethod +from typing import final +from ..utils import check_positive_integer, is_function + +_AGGREGATE_METHODS = {"sum": sum, "mean": lambda x: sum(x) / len(x)} class WeightingInterface(metaclass=ABCMeta): @@ -9,16 +13,99 @@ class WeightingInterface(metaclass=ABCMeta): should inherit from this class. """ - def __init__(self): + def __init__(self, update_every_n_epochs=1, aggregator="sum"): """ Initialization of the :class:`WeightingInterface` class. + + :param int update_every_n_epochs: The number of training epochs between + weight updates. If set to 1, the weights are updated at every epoch. + This parameter is ignored by static weighting schemes. Default is 1. + :param aggregator: The aggregation method. Either: + - 'sum' → torch.sum + - 'mean' → torch.mean + - callable → custom aggregation function + :type aggregator: str | Callable """ - self.condition_names = None + # Check consistency + check_positive_integer(value=update_every_n_epochs, strict=True) + + # Aggregation + if isinstance(aggregator, str): + if aggregator not in _AGGREGATE_METHODS: + raise ValueError( + f"Invalid aggregator '{aggregator}'. Must be one of " + f"{list(_AGGREGATE_METHODS.keys())}." + ) + aggregator = _AGGREGATE_METHODS[aggregator] + + elif not is_function(aggregator): + raise TypeError( + f"Aggregator must be either a string or a callable, " + f"got {type(aggregator).__name__}." + ) + + # Initialization + self._solver = None + self.update_every_n_epochs = update_every_n_epochs + self.aggregator_fn = aggregator + self._saved_weights = {} @abstractmethod + def weights_update(self, losses): + """ + Update the weighting scheme based on the given losses. + + This method must be implemented by subclasses. Its role is to update the + values of the weights. The updated weights will then be used by + :meth:`aggregate` to compute the final aggregated loss. + + :param dict losses: The dictionary of losses. + :return: The updated weights. + :rtype: dict + """ + + @final def aggregate(self, losses): """ - Aggregate the losses. + Update the weights (if needed) and aggregate the given losses. + + This method first checks whether the loss weights need to be updated + based on the current epoch and the ``update_every_n_epochs`` setting. + If an update is required, it calls :meth:`weights_update` to refresh the + weights. Afterwards, it aggregates the (weighted) losses into a single + scalar tensor using the configured aggregator function. This method must + not be overridden. :param dict losses: The dictionary of losses. + :return: The aggregated loss tensor. + :rtype: torch.Tensor + """ + # Update weights + if self.solver.trainer.current_epoch % self.update_every_n_epochs == 0: + self._saved_weights = self.weights_update(losses) + + # Aggregate. Using direct indexing instead of .get() ensures that a + # KeyError is raised if the expected condition is missing from the dict. + return self.aggregator_fn( + self._saved_weights[condition] * loss + for condition, loss in losses.items() + ) + + def last_saved_weights(self): + """ + Get the last saved weights. + + :return: The last saved weights. + :rtype: dict + """ + return self._saved_weights + + @property + def solver(self): + """ + The solver employing this weighting schema. + + :return: The solver. + :rtype: :class:`~pina.solver.SolverInterface` """ + return self._solver diff --git a/pina/model/block/pod_block.py b/pina/model/block/pod_block.py index 0c7990dfe..5ea2a35af 100644 --- a/pina/model/block/pod_block.py +++ b/pina/model/block/pod_block.py @@ -1,7 +1,7 @@ """Module for Base Continuous Convolution class.""" -import torch import warnings +import torch class PODBlock(torch.nn.Module): @@ -29,9 +29,10 @@ def __init__(self, rank, scale_coefficients=True): """ super().__init__() self.__scale_coefficients = scale_coefficients - self._basis = None + self.register_buffer("_basis", None) self._singular_values = None - self._scaler = None + self.register_buffer("_std", None) + self.register_buffer("_mean", None) self._rank = rank @property @@ -94,12 +95,12 @@ def scaler(self): :return: The scaler dictionary. :rtype: dict """ - if self._scaler is None: + if self._std is None: return None return { - "mean": self._scaler["mean"][: self.rank], - "std": self._scaler["std"][: self.rank], + "mean": self._mean[: self.rank], + "std": self._std[: self.rank], } @property @@ -119,6 +120,10 @@ def fit(self, X, randomized=True): are scaled after the projection to have zero mean and unit variance. :param torch.Tensor X: The input tensor to be reduced. + :param bool randomized: If ``True``, a randomized algorithm is used to + compute the POD basis. In general, this leads to faster + computations, but the results may be less accurate. Default is + ``True``. """ self._fit_pod(X, randomized) @@ -132,10 +137,8 @@ def _fit_scaler(self, coeffs): :param torch.Tensor coeffs: The coefficients to be scaled. """ - self._scaler = { - "std": torch.std(coeffs, dim=1), - "mean": torch.mean(coeffs, dim=1), - } + self._std = torch.std(coeffs, dim=1) # pylint: disable=W0201 + self._mean = torch.mean(coeffs, dim=1) # pylint: disable=W0201 def _fit_pod(self, X, randomized): """ @@ -154,13 +157,14 @@ def _fit_pod(self, X, randomized): else: if randomized: warnings.warn( - "Considering a randomized algorithm to compute the POD basis" + "Considering a randomized algorithm to compute the POD " + "basis" ) u, s, _ = torch.svd_lowrank(X.T, q=X.shape[0]) else: u, s, _ = torch.svd(X.T) - self._basis = u.T + self._basis = u.T # pylint: disable=W0201 self._singular_values = s def forward(self, X): diff --git a/pina/model/layers/__init__.py b/pina/model/layers/__init__.py deleted file mode 100644 index aeef265c9..000000000 --- a/pina/model/layers/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -"""Old layers module, deprecated in 0.2.0.""" - -import warnings - -from ..block import * -from ...utils import custom_warning_format - -# back-compatibility 0.1 -# Set the custom format for warnings -warnings.formatwarning = custom_warning_format -warnings.filterwarnings("always", category=DeprecationWarning) -warnings.warn( - "'pina.model.layers' is deprecated and will be removed " - "in future versions. Please use 'pina.model.block' instead.", - DeprecationWarning, -) diff --git a/pina/operator.py b/pina/operator.py index cb2a2b66b..bf2351bce 100644 --- a/pina/operator.py +++ b/pina/operator.py @@ -221,6 +221,7 @@ def fast_laplacian(output_, input_, components, d, method="std"): divergence of the gradient. Default is ``std``. :return: The computed laplacian tensor. :rtype: LabelTensor + :raises ValueError: If the passed method is neither ``std`` nor ``divgrad``. """ # Scalar laplacian if output_.shape[-1] == 1: @@ -415,8 +416,13 @@ def laplacian(output_, input_, components=None, d=None, method="std"): components, d = _check_values( output_=output_, input_=input_, components=components, d=d ) + return fast_laplacian( - output_=output_, input_=input_, components=components, d=d + output_=output_, + input_=input_, + components=components, + d=d, + method=method, ) diff --git a/pina/operators.py b/pina/operators.py deleted file mode 100644 index cb2fb5e00..000000000 --- a/pina/operators.py +++ /dev/null @@ -1,16 +0,0 @@ -"""Old module for operators. Deprecated in 0.2.0.""" - -import warnings - -from .operator import * -from .utils import custom_warning_format - -# back-compatibility 0.1 -# Set the custom format for warnings -warnings.formatwarning = custom_warning_format -warnings.filterwarnings("always", category=DeprecationWarning) -warnings.warn( - "'pina.operators' is deprecated and will be removed " - "in future versions. Please use 'pina.operator' instead.", - DeprecationWarning, -) diff --git a/pina/plotter.py b/pina/plotter.py deleted file mode 100644 index fcd4dedba..000000000 --- a/pina/plotter.py +++ /dev/null @@ -1,3 +0,0 @@ -"""Module for Plotter""" - -raise ImportError("'pina.plotter' is deprecated and cannot be imported.") diff --git a/pina/problem/zoo/advection.py b/pina/problem/zoo/advection.py index a2e801562..74bac9b22 100644 --- a/pina/problem/zoo/advection.py +++ b/pina/problem/zoo/advection.py @@ -2,42 +2,10 @@ import torch from ... import Condition -from ...operator import grad -from ...equation import Equation -from ...domain import CartesianDomain -from ...utils import check_consistency from ...problem import SpatialProblem, TimeDependentProblem - - -class AdvectionEquation(Equation): - """ - Implementation of the advection equation. - """ - - def __init__(self, c): - """ - Initialization of the :class:`AdvectionEquation`. - - :param c: The advection velocity parameter. - :type c: float | int - """ - self.c = c - check_consistency(self.c, (float, int)) - - def equation(input_, output_): - """ - Implementation of the advection equation. - - :param LabelTensor input_: Input data of the problem. - :param LabelTensor output_: Output data of the problem. - :return: The residual of the advection equation. - :rtype: LabelTensor - """ - u_x = grad(output_, input_, components=["u"], d=["x"]) - u_t = grad(output_, input_, components=["u"], d=["t"]) - return u_t + self.c * u_x - - super().__init__(equation) +from ...equation import Equation, Advection +from ...utils import check_consistency +from ...domain import CartesianDomain def initial_condition(input_, output_): @@ -89,13 +57,10 @@ def __init__(self, c=1.0): :type c: float | int """ super().__init__() - + check_consistency(c, (float, int)) self.c = c - check_consistency(self.c, (float, int)) - self.conditions["D"] = Condition( - domain="D", equation=AdvectionEquation(self.c) - ) + self.conditions["D"] = Condition(domain="D", equation=Advection(self.c)) def solution(self, pts): """ diff --git a/pina/problem/zoo/allen_cahn.py b/pina/problem/zoo/allen_cahn.py index 4e05eaf68..c88285338 100644 --- a/pina/problem/zoo/allen_cahn.py +++ b/pina/problem/zoo/allen_cahn.py @@ -2,32 +2,18 @@ import torch from ... import Condition -from ...equation import Equation -from ...domain import CartesianDomain -from ...operator import grad, laplacian from ...problem import SpatialProblem, TimeDependentProblem - - -def allen_cahn_equation(input_, output_): - """ - Implementation of the Allen Cahn equation. - - :param LabelTensor input_: Input data of the problem. - :param LabelTensor output_: Output data of the problem. - :return: The residual of the Allen Cahn equation. - :rtype: LabelTensor - """ - u_t = grad(output_, input_, components=["u"], d=["t"]) - u_xx = laplacian(output_, input_, components=["u"], d=["x"]) - return u_t - 0.0001 * u_xx + 5 * output_**3 - 5 * output_ +from ...equation import Equation, AllenCahn +from ...utils import check_consistency +from ...domain import CartesianDomain def initial_condition(input_, output_): """ Definition of the initial condition of the Allen Cahn problem. - :param LabelTensor input_: Input data of the problem. - :param LabelTensor output_: Output data of the problem. + :param LabelTensor input_: The input data of the problem. + :param LabelTensor output_: The output data of the problem. :return: The residual of the initial condition. :rtype: LabelTensor """ @@ -64,6 +50,25 @@ class AllenCahnProblem(TimeDependentProblem, SpatialProblem): } conditions = { - "D": Condition(domain="D", equation=Equation(allen_cahn_equation)), "t0": Condition(domain="t0", equation=Equation(initial_condition)), } + + def __init__(self, alpha=1e-4, beta=5): + """ + Initialization of the :class:`AllenCahnProblem`. + + :param alpha: The diffusion coefficient. + :type alpha: float | int + :param beta: The reaction coefficient. + :type beta: float | int + """ + super().__init__() + check_consistency(alpha, (float, int)) + check_consistency(beta, (float, int)) + self.alpha = alpha + self.beta = beta + + self.conditions["D"] = Condition( + domain="D", + equation=AllenCahn(alpha=self.alpha, beta=self.beta), + ) diff --git a/pina/problem/zoo/diffusion_reaction.py b/pina/problem/zoo/diffusion_reaction.py index d7a26c59a..416cdb253 100644 --- a/pina/problem/zoo/diffusion_reaction.py +++ b/pina/problem/zoo/diffusion_reaction.py @@ -2,40 +2,18 @@ import torch from ... import Condition -from ...domain import CartesianDomain -from ...operator import grad, laplacian -from ...equation import Equation, FixedValue +from ...equation import Equation, FixedValue, DiffusionReaction from ...problem import SpatialProblem, TimeDependentProblem - - -def diffusion_reaction(input_, output_): - """ - Implementation of the diffusion-reaction equation. - - :param LabelTensor input_: Input data of the problem. - :param LabelTensor output_: Output data of the problem. - :return: The residual of the diffusion-reaction equation. - :rtype: LabelTensor - """ - x = input_.extract("x") - t = input_.extract("t") - u_t = grad(output_, input_, components=["u"], d=["t"]) - u_xx = laplacian(output_, input_, components=["u"], d=["x"]) - r = torch.exp(-t) * ( - 1.5 * torch.sin(2 * x) - + (8 / 3) * torch.sin(3 * x) - + (15 / 4) * torch.sin(4 * x) - + (63 / 8) * torch.sin(8 * x) - ) - return u_t - u_xx - r +from ...utils import check_consistency +from ...domain import CartesianDomain def initial_condition(input_, output_): """ Definition of the initial condition of the diffusion-reaction problem. - :param LabelTensor input_: Input data of the problem. - :param LabelTensor output_: Output data of the problem. + :param LabelTensor input_: The input data of the problem. + :param LabelTensor output_: The output data of the problem. :return: The residual of the initial condition. :rtype: LabelTensor """ @@ -76,12 +54,43 @@ class DiffusionReactionProblem(TimeDependentProblem, SpatialProblem): } conditions = { - "D": Condition(domain="D", equation=Equation(diffusion_reaction)), "g1": Condition(domain="g1", equation=FixedValue(0.0)), "g2": Condition(domain="g2", equation=FixedValue(0.0)), "t0": Condition(domain="t0", equation=Equation(initial_condition)), } + def __init__(self, alpha=1e-4): + """ + Initialization of the :class:`DiffusionReactionProblem`. + + :param alpha: The diffusion coefficient. + :type alpha: float | int + """ + super().__init__() + check_consistency(alpha, (float, int)) + self.alpha = alpha + + def forcing_term(input_): + """ + Implementation of the forcing term. + """ + # Extract spatial and temporal variables + spatial_d = [di for di in input_.labels if di != "t"] + x = input_.extract(spatial_d) + t = input_.extract("t") + + return torch.exp(-t) * ( + 1.5 * torch.sin(2 * x) + + (8 / 3) * torch.sin(3 * x) + + (15 / 4) * torch.sin(4 * x) + + (63 / 8) * torch.sin(8 * x) + ) + + self.conditions["D"] = Condition( + domain="D", + equation=DiffusionReaction(self.alpha, forcing_term), + ) + def solution(self, pts): """ Implementation of the analytical solution of the diffusion-reaction diff --git a/pina/problem/zoo/helmholtz.py b/pina/problem/zoo/helmholtz.py index 34d389319..5f3f956af 100644 --- a/pina/problem/zoo/helmholtz.py +++ b/pina/problem/zoo/helmholtz.py @@ -2,46 +2,10 @@ import torch from ... import Condition -from ...operator import laplacian +from ...equation import FixedValue, Helmholtz +from ...utils import check_consistency from ...domain import CartesianDomain from ...problem import SpatialProblem -from ...utils import check_consistency -from ...equation import Equation, FixedValue - - -class HelmholtzEquation(Equation): - """ - Implementation of the Helmholtz equation. - """ - - def __init__(self, alpha): - """ - Initialization of the :class:`HelmholtzEquation` class. - - :param alpha: Parameter of the forcing term. - :type alpha: float | int - """ - self.alpha = alpha - check_consistency(alpha, (int, float)) - - def equation(input_, output_): - """ - Implementation of the Helmholtz equation. - - :param LabelTensor input_: Input data of the problem. - :param LabelTensor output_: Output data of the problem. - :return: The residual of the Helmholtz equation. - :rtype: LabelTensor - """ - lap = laplacian(output_, input_, components=["u"], d=["x", "y"]) - q = ( - (1 - 2 * (self.alpha * torch.pi) ** 2) - * torch.sin(self.alpha * torch.pi * input_.extract("x")) - * torch.sin(self.alpha * torch.pi * input_.extract("y")) - ) - return lap + output_ - q - - super().__init__(equation) class HelmholtzProblem(SpatialProblem): @@ -88,8 +52,19 @@ def __init__(self, alpha=3.0): self.alpha = alpha check_consistency(alpha, (int, float)) + def forcing_term(self, input_): + """ + Implementation of the forcing term. + """ + return ( + (1 - 2 * (self.alpha * torch.pi) ** 2) + * torch.sin(self.alpha * torch.pi * input_.extract("x")) + * torch.sin(self.alpha * torch.pi * input_.extract("y")) + ) + self.conditions["D"] = Condition( - domain="D", equation=HelmholtzEquation(self.alpha) + domain="D", + equation=Helmholtz(self.alpha, forcing_term), ) def solution(self, pts): diff --git a/pina/problem/zoo/poisson_2d_square.py b/pina/problem/zoo/poisson_2d_square.py index c6644c462..27d7fc870 100644 --- a/pina/problem/zoo/poisson_2d_square.py +++ b/pina/problem/zoo/poisson_2d_square.py @@ -1,29 +1,25 @@ """Formulation of the Poisson problem in a square domain.""" import torch -from ... import Condition -from ...operator import laplacian +from ...equation import FixedValue, Poisson from ...problem import SpatialProblem from ...domain import CartesianDomain -from ...equation import Equation, FixedValue +from ... import Condition -def laplace_equation(input_, output_): +def forcing_term(input_): """ - Implementation of the laplace equation. + Implementation of the forcing term of the Poisson problem. - :param LabelTensor input_: Input data of the problem. - :param LabelTensor output_: Output data of the problem. - :return: The residual of the laplace equation. + :param LabelTensor input_: The points where the forcing term is evaluated. + :return: The forcing term of the Poisson problem. :rtype: LabelTensor """ - force_term = ( + return ( torch.sin(input_.extract(["x"]) * torch.pi) * torch.sin(input_.extract(["y"]) * torch.pi) * (2 * torch.pi**2) ) - delta_u = laplacian(output_, input_, components=["u"], d=["x", "y"]) - return delta_u - force_term class Poisson2DSquareProblem(SpatialProblem): @@ -51,14 +47,14 @@ class Poisson2DSquareProblem(SpatialProblem): "g2": Condition(domain="g2", equation=FixedValue(0.0)), "g3": Condition(domain="g3", equation=FixedValue(0.0)), "g4": Condition(domain="g4", equation=FixedValue(0.0)), - "D": Condition(domain="D", equation=Equation(laplace_equation)), + "D": Condition(domain="D", equation=Poisson(forcing_term=forcing_term)), } def solution(self, pts): """ Implementation of the analytical solution of the Poisson problem. - :param LabelTensor pts: Points where the solution is evaluated. + :param LabelTensor pts: The points where the solution is evaluated. :return: The analytical solution of the Poisson problem. :rtype: LabelTensor """ diff --git a/pina/solver/physics_informed_solver/pinn_interface.py b/pina/solver/physics_informed_solver/pinn_interface.py index 976f6ce6b..9155e19ec 100644 --- a/pina/solver/physics_informed_solver/pinn_interface.py +++ b/pina/solver/physics_informed_solver/pinn_interface.py @@ -1,8 +1,10 @@ """Module for the Physics-Informed Neural Network Interface.""" from abc import ABCMeta, abstractmethod +import warnings import torch +from ...utils import custom_warning_format from ..supervised_solver import SupervisedSolverInterface from ...condition import ( InputTargetCondition, @@ -10,6 +12,10 @@ DomainEquationCondition, ) +# set the warning for torch >= 2.8 compile +warnings.formatwarning = custom_warning_format +warnings.filterwarnings("always", category=UserWarning) + class PINNInterface(SupervisedSolverInterface, metaclass=ABCMeta): """ @@ -46,6 +52,36 @@ def __init__(self, **kwargs): # current condition name self.__metric = None + def setup(self, stage): + """ + Setup method executed at the beginning of training and testing. + + This method compiles the model only if the installed torch version + is earlier than 2.8, due to known issues with later versions + (see https://github.com/mathLab/PINA/issues/621). + + .. warning:: + For torch >= 2.8, compilation is disabled. Forcing compilation + on these versions may cause runtime errors or unstable behavior. + + :param str stage: The current stage of the training process + (e.g., ``fit``, ``validate``, ``test``, ``predict``). + :return: The result of the parent class ``setup`` method. + :rtype: Any + """ + # Override the compilation, compiling only for torch < 2.8, see + # related issue at https://github.com/mathLab/PINA/issues/621 + if torch.__version__ < "2.8": + self.trainer.compile = True + else: + self.trainer.compile = False + warnings.warn( + "Compilation is disabled for torch >= 2.8. " + "Forcing compilation may cause runtime errors or instability.", + UserWarning, + ) + return super().setup(stage) + def optimization_cycle(self, batch, loss_residuals=None): """ The optimization cycle for the PINN solver. @@ -154,13 +190,9 @@ def compute_residual(self, samples, equation): :return: The residual of the solution of the model. :rtype: LabelTensor """ - try: - residual = equation.residual(samples, self.forward(samples)) - except TypeError: - # this occurs when the function has three inputs (inverse problem) - residual = equation.residual( - samples, self.forward(samples), self._params - ) + residual = equation.residual( + samples, self.forward(samples), self._params + ) return residual def _residual_loss(self, samples, equation): diff --git a/pina/solver/solver.py b/pina/solver/solver.py index f6bcc2ac2..6948ec664 100644 --- a/pina/solver/solver.py +++ b/pina/solver/solver.py @@ -44,7 +44,7 @@ def __init__(self, problem, weighting, use_lt): weighting = _NoWeighting() check_consistency(weighting, WeightingInterface) self._pina_weighting = weighting - weighting.condition_names = list(self._pina_problem.conditions.keys()) + weighting._solver = self # check consistency use_lt check_consistency(use_lt, bool) @@ -169,7 +169,10 @@ def setup(self, stage): compile the model if the :class:`~pina.trainer.Trainer` ``compile`` is ``True``. - + :param str stage: The current stage of the training process + (e.g., ``fit``, ``validate``, ``test``, ``predict``). + :return: The result of the parent class ``setup`` method. + :rtype: Any """ if stage == "fit" and self.trainer.compile: self._setup_compile() diff --git a/pina/solvers/__init__.py b/pina/solvers/__init__.py deleted file mode 100644 index 366b1b7b9..000000000 --- a/pina/solvers/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -"""Old module for solvers. Deprecated in 0.2.0 .""" - -import warnings - -from ..solver import * -from ..utils import custom_warning_format - -# back-compatibility 0.1 -# Set the custom format for warnings -warnings.formatwarning = custom_warning_format -warnings.filterwarnings("always", category=DeprecationWarning) -warnings.warn( - "'pina.solvers' is deprecated and will be removed " - "in future versions. Please use 'pina.solver' instead.", - DeprecationWarning, -) diff --git a/pina/solvers/pinns/__init__.py b/pina/solvers/pinns/__init__.py deleted file mode 100644 index 4ae88449a..000000000 --- a/pina/solvers/pinns/__init__.py +++ /dev/null @@ -1,17 +0,0 @@ -"""Old module for the PINNs solver. Deprecated in 0.2.0.""" - -import warnings - -from ...solver.physics_informed_solver import * -from ...utils import custom_warning_format - -# back-compatibility 0.1 -# Set the custom format for warnings -warnings.formatwarning = custom_warning_format -warnings.filterwarnings("always", category=DeprecationWarning) -warnings.warn( - "'pina.solvers.pinns' is deprecated and will be removed " - "in future versions. Please use " - "'pina.solver.physics_informed_solver' instead.", - DeprecationWarning, -) diff --git a/pina/utils.py b/pina/utils.py index ddbd2e8ac..efc48424e 100644 --- a/pina/utils.py +++ b/pina/utils.py @@ -206,7 +206,7 @@ def is_function(f): :return: ``True`` if ``f`` is a function, ``False`` otherwise. :rtype: bool """ - return isinstance(f, (types.FunctionType, types.LambdaType)) + return callable(f) def chebyshev_roots(n): @@ -240,3 +240,31 @@ def check_positive_integer(value, strict=True): assert ( isinstance(value, int) and value >= 0 ), f"Expected a non-negative integer, got {value}." + + +def in_range(value, range_vals, strict=True): + """ + Check if a value is within a specified range. + + :param int value: The integer value to check. + :param list[int] range_vals: A list of two integers representing the range + limits. The first element specifies the lower bound, and the second + specifies the upper bound. + :param bool strict: If True, the value must be strictly positive. + Default is True. + :return: True if the value satisfies the range condition, False otherwise. + :rtype: bool + """ + # Validate inputs + check_consistency(value, (float, int)) + check_consistency(range_vals, (float, int)) + assert ( + isinstance(range_vals, list) and len(range_vals) == 2 + ), "range_vals must be a list of two integers [lower, upper]" + lower, upper = range_vals + + # Check the range + if strict: + return lower < value < upper + + return lower <= value <= upper diff --git a/pyproject.toml b/pyproject.toml index 3311f4ef9..1eb1583bb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "pina-mathlab" -version = "0.2.2" +version = "0.2.3" description = "Physic Informed Neural networks for Advance modeling." readme = "README.md" authors = [ diff --git a/tests/test_blocks/test_convolution.py b/tests/test_block/test_convolution.py similarity index 100% rename from tests/test_blocks/test_convolution.py rename to tests/test_block/test_convolution.py diff --git a/tests/test_blocks/test_embedding.py b/tests/test_block/test_embedding.py similarity index 100% rename from tests/test_blocks/test_embedding.py rename to tests/test_block/test_embedding.py diff --git a/tests/test_blocks/test_fourier.py b/tests/test_block/test_fourier.py similarity index 100% rename from tests/test_blocks/test_fourier.py rename to tests/test_block/test_fourier.py diff --git a/tests/test_blocks/test_low_rank_block.py b/tests/test_block/test_low_rank_block.py similarity index 100% rename from tests/test_blocks/test_low_rank_block.py rename to tests/test_block/test_low_rank_block.py diff --git a/tests/test_blocks/test_orthogonal.py b/tests/test_block/test_orthogonal.py similarity index 100% rename from tests/test_blocks/test_orthogonal.py rename to tests/test_block/test_orthogonal.py diff --git a/tests/test_blocks/test_pirate_network_block.py b/tests/test_block/test_pirate_network_block.py similarity index 100% rename from tests/test_blocks/test_pirate_network_block.py rename to tests/test_block/test_pirate_network_block.py diff --git a/tests/test_blocks/test_pod.py b/tests/test_block/test_pod.py similarity index 95% rename from tests/test_blocks/test_pod.py rename to tests/test_block/test_pod.py index 8cee923b9..d10625fc3 100644 --- a/tests/test_blocks/test_pod.py +++ b/tests/test_block/test_pod.py @@ -42,13 +42,14 @@ def test_fit(rank, scale, randomized): assert pod.singular_values.shape == (rank,) assert pod._singular_values.shape == (n_snap,) if scale is True: - assert pod._scaler["mean"].shape == (n_snap,) - assert pod._scaler["std"].shape == (n_snap,) + assert pod._mean.shape == (n_snap,) + assert pod._std.shape == (n_snap,) assert pod.scaler["mean"].shape == (rank,) assert pod.scaler["std"].shape == (rank,) assert pod.scaler["mean"].shape[0] == pod.basis.shape[0] else: - assert pod._scaler == None + assert pod._std == None + assert pod._mean == None assert pod.scaler == None diff --git a/tests/test_blocks/test_rbf.py b/tests/test_block/test_rbf.py similarity index 100% rename from tests/test_blocks/test_rbf.py rename to tests/test_block/test_rbf.py diff --git a/tests/test_blocks/test_residual.py b/tests/test_block/test_residual.py similarity index 100% rename from tests/test_blocks/test_residual.py rename to tests/test_block/test_residual.py diff --git a/tests/test_blocks/test_spectral_convolution.py b/tests/test_block/test_spectral_convolution.py similarity index 100% rename from tests/test_blocks/test_spectral_convolution.py rename to tests/test_block/test_spectral_convolution.py diff --git a/tests/test_callback/test_linear_weight_update_callback.py b/tests/test_callback/test_linear_weight_update_callback.py deleted file mode 100644 index c1f4cf357..000000000 --- a/tests/test_callback/test_linear_weight_update_callback.py +++ /dev/null @@ -1,164 +0,0 @@ -import pytest -import math -from pina.solver import PINN -from pina.loss import ScalarWeighting -from pina.trainer import Trainer -from pina.model import FeedForward -from pina.problem.zoo import Poisson2DSquareProblem as Poisson -from pina.callback import LinearWeightUpdate - - -# Define the problem -poisson_problem = Poisson() -poisson_problem.discretise_domain(50, "grid") -cond_name = list(poisson_problem.conditions.keys())[0] - -# Define the model -model = FeedForward( - input_dimensions=len(poisson_problem.input_variables), - output_dimensions=len(poisson_problem.output_variables), - layers=[32, 32], -) - -# Define the weighting schema -weights_dict = {key: 1 for key in poisson_problem.conditions.keys()} -weighting = ScalarWeighting(weights=weights_dict) - -# Define the solver -solver = PINN(problem=poisson_problem, model=model, weighting=weighting) - -# Value used for testing -epochs = 10 - - -@pytest.mark.parametrize("initial_value", [1, 5.5]) -@pytest.mark.parametrize("target_value", [10, 25.5]) -def test_constructor(initial_value, target_value): - LinearWeightUpdate( - target_epoch=epochs, - condition_name=cond_name, - initial_value=initial_value, - target_value=target_value, - ) - - # Target_epoch must be int - with pytest.raises(ValueError): - LinearWeightUpdate( - target_epoch=10.0, - condition_name=cond_name, - initial_value=0, - target_value=1, - ) - - # Condition_name must be str - with pytest.raises(ValueError): - LinearWeightUpdate( - target_epoch=epochs, - condition_name=100, - initial_value=0, - target_value=1, - ) - - # Initial_value must be float or int - with pytest.raises(ValueError): - LinearWeightUpdate( - target_epoch=epochs, - condition_name=cond_name, - initial_value="0", - target_value=1, - ) - - # Target_value must be float or int - with pytest.raises(ValueError): - LinearWeightUpdate( - target_epoch=epochs, - condition_name=cond_name, - initial_value=0, - target_value="1", - ) - - -@pytest.mark.parametrize("initial_value, target_value", [(1, 10), (10, 1)]) -def test_training(initial_value, target_value): - callback = LinearWeightUpdate( - target_epoch=epochs, - condition_name=cond_name, - initial_value=initial_value, - target_value=target_value, - ) - trainer = Trainer( - solver=solver, - callbacks=[callback], - accelerator="cpu", - max_epochs=epochs, - ) - trainer.train() - - # Check that the final weight value matches the target value - final_value = solver.weighting.weights[cond_name] - assert math.isclose(final_value, target_value) - - # Target_epoch must be greater than 0 - with pytest.raises(ValueError): - callback = LinearWeightUpdate( - target_epoch=0, - condition_name=cond_name, - initial_value=0, - target_value=1, - ) - trainer = Trainer( - solver=solver, - callbacks=[callback], - accelerator="cpu", - max_epochs=5, - ) - trainer.train() - - # Target_epoch must be less than or equal to max_epochs - with pytest.raises(ValueError): - callback = LinearWeightUpdate( - target_epoch=epochs, - condition_name=cond_name, - initial_value=0, - target_value=1, - ) - trainer = Trainer( - solver=solver, - callbacks=[callback], - accelerator="cpu", - max_epochs=epochs - 1, - ) - trainer.train() - - # Condition_name must be a problem condition - with pytest.raises(ValueError): - callback = LinearWeightUpdate( - target_epoch=epochs, - condition_name="not_a_condition", - initial_value=0, - target_value=1, - ) - trainer = Trainer( - solver=solver, - callbacks=[callback], - accelerator="cpu", - max_epochs=epochs, - ) - trainer.train() - - # Weighting schema must be ScalarWeighting - with pytest.raises(ValueError): - callback = LinearWeightUpdate( - target_epoch=epochs, - condition_name=cond_name, - initial_value=0, - target_value=1, - ) - unweighted_solver = PINN(problem=poisson_problem, model=model) - trainer = Trainer( - solver=unweighted_solver, - callbacks=[callback], - accelerator="cpu", - max_epochs=epochs, - ) - trainer.train() diff --git a/tests/test_callback/test_normalizer_data_callback.py b/tests/test_callback/test_normalizer_data_callback.py new file mode 100644 index 000000000..7cdcc9510 --- /dev/null +++ b/tests/test_callback/test_normalizer_data_callback.py @@ -0,0 +1,244 @@ +import torch +import pytest +from copy import deepcopy + +from pina import Trainer, LabelTensor, Condition +from pina.solver import SupervisedSolver +from pina.model import FeedForward +from pina.callback import NormalizerDataCallback +from pina.problem import AbstractProblem +from pina.problem.zoo import Poisson2DSquareProblem as Poisson +from pina.solver import PINN +from pina.graph import RadiusGraph + +# for checking normalization +stage_map = { + "train": ["train_dataset"], + "validate": ["val_dataset"], + "test": ["test_dataset"], + "all": ["train_dataset", "val_dataset", "test_dataset"], +} + +input_1 = torch.rand(20, 2) * 10 +target_1 = torch.rand(20, 1) * 10 +input_2 = torch.rand(20, 2) * 5 +target_2 = torch.rand(20, 1) * 5 + + +class LabelTensorProblem(AbstractProblem): + input_variables = ["u_0", "u_1"] + output_variables = ["u"] + conditions = { + "data1": Condition( + input=LabelTensor(input_1, ["u_0", "u_1"]), + target=LabelTensor(target_1, ["u"]), + ), + "data2": Condition( + input=LabelTensor(input_2, ["u_0", "u_1"]), + target=LabelTensor(target_2, ["u"]), + ), + } + + +class TensorProblem(AbstractProblem): + input_variables = ["u_0", "u_1"] + output_variables = ["u"] + conditions = { + "data1": Condition(input=input_1, target=target_1), + "data2": Condition(input=input_2, target=target_2), + } + + +input_graph = [RadiusGraph(radius=0.5, pos=torch.rand(10, 2)) for _ in range(5)] +output_graph = torch.rand(5, 1) + + +class GraphProblem(AbstractProblem): + input_variables = ["u_0", "u_1"] + output_variables = ["u"] + conditions = { + "data": Condition(input=input_graph, target=output_graph), + } + + +supervised_solver_no_lt = SupervisedSolver( + problem=TensorProblem(), model=FeedForward(2, 1), use_lt=False +) +supervised_solver_lt = SupervisedSolver( + problem=LabelTensorProblem(), model=FeedForward(2, 1), use_lt=True +) + +poisson_problem = Poisson() +poisson_problem.conditions["data"] = Condition( + input=LabelTensor(torch.rand(20, 2) * 10, ["x", "y"]), + target=LabelTensor(torch.rand(20, 1) * 10, ["u"]), +) + + +@pytest.mark.parametrize("scale_fn", [torch.std, torch.var]) +@pytest.mark.parametrize("shift_fn", [torch.mean, torch.median]) +@pytest.mark.parametrize("apply_to", ["input", "target"]) +@pytest.mark.parametrize("stage", ["train", "validate", "test", "all"]) +def test_init(scale_fn, shift_fn, apply_to, stage): + normalizer = NormalizerDataCallback( + scale_fn=scale_fn, shift_fn=shift_fn, apply_to=apply_to, stage=stage + ) + assert normalizer.scale_fn == scale_fn + assert normalizer.shift_fn == shift_fn + assert normalizer.apply_to == apply_to + assert normalizer.stage == stage + + +def test_init_invalid_scale(): + with pytest.raises(ValueError): + NormalizerDataCallback(scale_fn=1) + + +def test_init_invalid_shift(): + with pytest.raises(ValueError): + NormalizerDataCallback(shift_fn=1) + + +@pytest.mark.parametrize("invalid_apply_to", ["inputt", "targett", 1]) +def test_init_invalid_apply_to(invalid_apply_to): + with pytest.raises(ValueError): + NormalizerDataCallback(apply_to=invalid_apply_to) + + +@pytest.mark.parametrize("invalid_stage", ["trainn", "validatee", 1]) +def test_init_invalid_stage(invalid_stage): + with pytest.raises(ValueError): + NormalizerDataCallback(stage=invalid_stage) + + +@pytest.mark.parametrize( + "solver", [supervised_solver_lt, supervised_solver_no_lt] +) +@pytest.mark.parametrize( + "fn", [[torch.std, torch.mean], [torch.var, torch.median]] +) +@pytest.mark.parametrize("apply_to", ["input", "target"]) +@pytest.mark.parametrize("stage", ["all", "train", "validate", "test"]) +def test_setup(solver, fn, stage, apply_to): + scale_fn, shift_fn = fn + trainer = Trainer( + solver=solver, + callbacks=NormalizerDataCallback( + scale_fn=scale_fn, shift_fn=shift_fn, stage=stage, apply_to=apply_to + ), + max_epochs=1, + train_size=0.4, + val_size=0.3, + test_size=0.3, + shuffle=False, + ) + trainer_copy = deepcopy(trainer) + trainer_copy.data_module.setup("fit") + trainer_copy.data_module.setup("test") + trainer.train() + trainer.test() + + normalizer = trainer.callbacks[0].normalizer + + for cond in ["data1", "data2"]: + scale = scale_fn( + trainer_copy.data_module.train_dataset.conditions_dict[cond][ + apply_to + ] + ) + shift = shift_fn( + trainer_copy.data_module.train_dataset.conditions_dict[cond][ + apply_to + ] + ) + assert "scale" in normalizer[cond] + assert "shift" in normalizer[cond] + assert normalizer[cond]["scale"] - scale < 1e-5 + assert normalizer[cond]["shift"] - shift < 1e-5 + for ds_name in stage_map[stage]: + dataset = getattr(trainer.data_module, ds_name, None) + old_dataset = getattr(trainer_copy.data_module, ds_name, None) + current_points = dataset.conditions_dict[cond][apply_to] + old_points = old_dataset.conditions_dict[cond][apply_to] + expected = (old_points - shift) / scale + assert torch.allclose(current_points, expected) + + +@pytest.mark.parametrize( + "fn", [[torch.std, torch.mean], [torch.var, torch.median]] +) +@pytest.mark.parametrize("apply_to", ["input"]) +@pytest.mark.parametrize("stage", ["all", "train", "validate", "test"]) +def test_setup_pinn(fn, stage, apply_to): + scale_fn, shift_fn = fn + pinn = PINN( + problem=poisson_problem, + model=FeedForward(2, 1), + ) + poisson_problem.discretise_domain(n=10) + trainer = Trainer( + solver=pinn, + callbacks=NormalizerDataCallback( + scale_fn=scale_fn, + shift_fn=shift_fn, + stage=stage, + apply_to=apply_to, + ), + max_epochs=1, + train_size=0.4, + val_size=0.3, + test_size=0.3, + shuffle=False, + ) + + trainer_copy = deepcopy(trainer) + trainer_copy.data_module.setup("fit") + trainer_copy.data_module.setup("test") + trainer.train() + trainer.test() + + conditions = trainer.callbacks[0].normalizer.keys() + assert "data" in conditions + assert len(conditions) == 1 + normalizer = trainer.callbacks[0].normalizer + cond = "data" + + scale = scale_fn( + trainer_copy.data_module.train_dataset.conditions_dict[cond][apply_to] + ) + shift = shift_fn( + trainer_copy.data_module.train_dataset.conditions_dict[cond][apply_to] + ) + assert "scale" in normalizer[cond] + assert "shift" in normalizer[cond] + assert normalizer[cond]["scale"] - scale < 1e-5 + assert normalizer[cond]["shift"] - shift < 1e-5 + for ds_name in stage_map[stage]: + dataset = getattr(trainer.data_module, ds_name, None) + old_dataset = getattr(trainer_copy.data_module, ds_name, None) + current_points = dataset.conditions_dict[cond][apply_to] + old_points = old_dataset.conditions_dict[cond][apply_to] + expected = (old_points - shift) / scale + assert torch.allclose(current_points, expected) + + +def test_setup_graph_dataset(): + solver = SupervisedSolver( + problem=GraphProblem(), model=FeedForward(2, 1), use_lt=False + ) + trainer = Trainer( + solver=solver, + callbacks=NormalizerDataCallback( + scale_fn=torch.std, + shift_fn=torch.mean, + stage="all", + apply_to="input", + ), + max_epochs=1, + train_size=0.4, + val_size=0.3, + test_size=0.3, + shuffle=False, + ) + with pytest.raises(NotImplementedError): + trainer.train() diff --git a/tests/test_data/test_graph_dataset.py b/tests/test_data/test_graph_dataset.py index a49b0adb5..81d6a2c5d 100644 --- a/tests/test_data/test_graph_dataset.py +++ b/tests/test_data/test_graph_dataset.py @@ -101,7 +101,7 @@ def test_getitem(conditions_dict, max_conditions_lengths): [d["input"].x.shape == torch.Size((400, 10)) for d in data.values()] ) assert all( - [d["target"].shape == torch.Size((400, 10)) for d in data.values()] + [d["target"].shape == torch.Size((20, 20, 10)) for d in data.values()] ) assert all( [ diff --git a/tests/test_geometry/test_cartesian.py b/tests/test_domain/test_cartesian.py similarity index 100% rename from tests/test_geometry/test_cartesian.py rename to tests/test_domain/test_cartesian.py diff --git a/tests/test_geometry/test_difference.py b/tests/test_domain/test_difference.py similarity index 100% rename from tests/test_geometry/test_difference.py rename to tests/test_domain/test_difference.py diff --git a/tests/test_geometry/test_ellipsoid.py b/tests/test_domain/test_ellipsoid.py similarity index 100% rename from tests/test_geometry/test_ellipsoid.py rename to tests/test_domain/test_ellipsoid.py diff --git a/tests/test_geometry/test_exclusion.py b/tests/test_domain/test_exclusion.py similarity index 100% rename from tests/test_geometry/test_exclusion.py rename to tests/test_domain/test_exclusion.py diff --git a/tests/test_geometry/test_intersection.py b/tests/test_domain/test_intersection.py similarity index 100% rename from tests/test_geometry/test_intersection.py rename to tests/test_domain/test_intersection.py diff --git a/tests/test_geometry/test_simplex.py b/tests/test_domain/test_simplex.py similarity index 100% rename from tests/test_geometry/test_simplex.py rename to tests/test_domain/test_simplex.py diff --git a/tests/test_geometry/test_union.py b/tests/test_domain/test_union.py similarity index 100% rename from tests/test_geometry/test_union.py rename to tests/test_domain/test_union.py diff --git a/tests/test_equations/test_equation.py b/tests/test_equation/test_equation.py similarity index 100% rename from tests/test_equations/test_equation.py rename to tests/test_equation/test_equation.py diff --git a/tests/test_equation/test_equation_factory.py b/tests/test_equation/test_equation_factory.py new file mode 100644 index 000000000..4a9875115 --- /dev/null +++ b/tests/test_equation/test_equation_factory.py @@ -0,0 +1,197 @@ +from pina.equation import ( + FixedValue, + FixedGradient, + FixedFlux, + FixedLaplacian, + Advection, + AllenCahn, + DiffusionReaction, + Helmholtz, + Poisson, +) +from pina import LabelTensor +import torch +import pytest + +# Define input and output values +pts = LabelTensor(torch.rand(10, 3, requires_grad=True), labels=["x", "y", "t"]) +u = torch.pow(pts, 2) +u.labels = ["u", "v", "w"] + + +@pytest.mark.parametrize("value", [0, 10, -7.5]) +@pytest.mark.parametrize("components", [None, "u", ["u", "w"]]) +def test_fixed_value(value, components): + + # Constructor + equation = FixedValue(value=value, components=components) + + # Residual + residual = equation.residual(pts, u) + len_c = len(components) if components is not None else u.shape[1] + assert residual.shape == (pts.shape[0], len_c) + + +@pytest.mark.parametrize("value", [0, 10, -7.5]) +@pytest.mark.parametrize("components", [None, "u", ["u", "w"]]) +@pytest.mark.parametrize("d", [None, "x", ["x", "y"]]) +def test_fixed_gradient(value, components, d): + + # Constructor + equation = FixedGradient(value=value, components=components, d=d) + + # Residual + residual = equation.residual(pts, u) + len_c = len(components) if components is not None else u.shape[1] + len_d = len(d) if d is not None else pts.shape[1] + assert residual.shape == (pts.shape[0], len_c * len_d) + + +@pytest.mark.parametrize("value", [0, 10, -7.5]) +@pytest.mark.parametrize("components", [None, "u", ["u", "w"]]) +@pytest.mark.parametrize("d", [None, "x", ["x", "y"]]) +def test_fixed_flux(value, components, d): + + # Divergence requires components and d to be of the same length + len_c = len(components) if components is not None else u.shape[1] + len_d = len(d) if d is not None else pts.shape[1] + if len_c != len_d: + return + + # Constructor + equation = FixedFlux(value=value, components=components, d=d) + + # Residual + residual = equation.residual(pts, u) + assert residual.shape == (pts.shape[0], 1) + + +@pytest.mark.parametrize("value", [0, 10, -7.5]) +@pytest.mark.parametrize("components", [None, "u", ["u", "w"]]) +@pytest.mark.parametrize("d", [None, "x", ["x", "y"]]) +def test_fixed_laplacian(value, components, d): + + # Constructor + equation = FixedLaplacian(value=value, components=components, d=d) + + # Residual + residual = equation.residual(pts, u) + len_c = len(components) if components is not None else u.shape[1] + assert residual.shape == (pts.shape[0], len_c) + + +@pytest.mark.parametrize("c", [1.0, 10, [1, 2.5]]) +def test_advection_equation(c): + + # Constructor + equation = Advection(c) + + # Should fail if c is an empty list + with pytest.raises(ValueError): + Advection([]) + + # Should fail if c is not a float, int, or list + with pytest.raises(ValueError): + Advection("invalid") + + # Residual + residual = equation.residual(pts, u) + assert residual.shape == u.shape + + # Should fail if the input has no 't' label + with pytest.raises(ValueError): + residual = equation.residual(pts["x", "y"], u) + + # Should fail if c is a list and its length != spatial dimension + with pytest.raises(ValueError): + Advection([1, 2, 3]) + residual = equation.residual(pts, u) + + +@pytest.mark.parametrize("alpha", [1.0, 10, -7.5]) +@pytest.mark.parametrize("beta", [1.0, 10, -7.5]) +def test_allen_cahn_equation(alpha, beta): + + # Constructor + equation = AllenCahn(alpha=alpha, beta=beta) + + # Should fail if alpha is not a float or int + with pytest.raises(ValueError): + AllenCahn(alpha="invalid", beta=beta) + + # Should fail if beta is not a float or int + with pytest.raises(ValueError): + AllenCahn(alpha=alpha, beta="invalid") + + # Residual + residual = equation.residual(pts, u) + assert residual.shape == u.shape + + # Should fail if the input has no 't' label + with pytest.raises(ValueError): + residual = equation.residual(pts["x", "y"], u) + + +@pytest.mark.parametrize("alpha", [1.0, 10, -7.5]) +@pytest.mark.parametrize( + "forcing_term", [lambda x: torch.sin(x), lambda x: torch.exp(x)] +) +def test_diffusion_reaction_equation(alpha, forcing_term): + + # Constructor + equation = DiffusionReaction(alpha=alpha, forcing_term=forcing_term) + + # Should fail if alpha is not a float or int + with pytest.raises(ValueError): + DiffusionReaction(alpha="invalid", forcing_term=forcing_term) + + # Should fail if forcing_term is not a callable + with pytest.raises(ValueError): + DiffusionReaction(alpha=alpha, forcing_term="invalid") + + # Residual + residual = equation.residual(pts, u) + assert residual.shape == u.shape + + # Should fail if the input has no 't' label + with pytest.raises(ValueError): + residual = equation.residual(pts["x", "y"], u) + + +@pytest.mark.parametrize("k", [1.0, 10, -7.5]) +@pytest.mark.parametrize( + "forcing_term", [lambda x: torch.sin(x), lambda x: torch.exp(x)] +) +def test_helmholtz_equation(k, forcing_term): + + # Constructor + equation = Helmholtz(k=k, forcing_term=forcing_term) + + # Should fail if k is not a float or int + with pytest.raises(ValueError): + Helmholtz(k="invalid", forcing_term=forcing_term) + + # Should fail if forcing_term is not a callable + with pytest.raises(ValueError): + Helmholtz(k=k, forcing_term="invalid") + + # Residual + residual = equation.residual(pts, u) + assert residual.shape == u.shape + + +@pytest.mark.parametrize( + "forcing_term", [lambda x: torch.sin(x), lambda x: torch.exp(x)] +) +def test_poisson_equation(forcing_term): + + # Constructor + equation = Poisson(forcing_term=forcing_term) + + # Should fail if forcing_term is not a callable + with pytest.raises(ValueError): + Poisson(forcing_term="invalid") + + # Residual + residual = equation.residual(pts, u) + assert residual.shape == u.shape diff --git a/tests/test_equations/test_system_equation.py b/tests/test_equation/test_system_equation.py similarity index 100% rename from tests/test_equations/test_system_equation.py rename to tests/test_equation/test_system_equation.py diff --git a/tests/test_operator.py b/tests/test_operator.py index aade70021..572020c99 100644 --- a/tests/test_operator.py +++ b/tests/test_operator.py @@ -253,7 +253,8 @@ def test_divergence(f): Function(), ids=["scalar_scalar", "scalar_vector", "vector_scalar", "vector_vector"], ) -def test_laplacian(f): +@pytest.mark.parametrize("method", ["std", "divgrad"]) +def test_laplacian(f, method): # Unpack the function func_input, func, _, _, func_lap = f @@ -265,7 +266,7 @@ def test_laplacian(f): output_ = LabelTensor(output_, labels) # Compute the true laplacian and the pina laplacian - pina_lap = laplacian(output_=output_, input_=input_) + pina_lap = laplacian(output_=output_, input_=input_, method=method) true_lap = func_lap(input_) # Check the shape and labels of the laplacian @@ -276,24 +277,34 @@ def test_laplacian(f): assert torch.allclose(pina_lap, true_lap) # Test if labels are handled correctly - laplacian(output_=output_, input_=input_, components=output_.labels[0]) - laplacian(output_=output_, input_=input_, d=input_.labels[0]) + laplacian( + output_=output_, + input_=input_, + components=output_.labels[0], + method=method, + ) + laplacian(output_=output_, input_=input_, d=input_.labels[0], method=method) # Should fail if input not a LabelTensor with pytest.raises(TypeError): - laplacian(output_=output_, input_=input_.tensor) + laplacian(output_=output_, input_=input_.tensor, method=method) # Should fail if output not a LabelTensor with pytest.raises(TypeError): - laplacian(output_=output_.tensor, input_=input_) + laplacian(output_=output_.tensor, input_=input_, method=method) # Should fail for non-existent input labels with pytest.raises(RuntimeError): - laplacian(output_=output_, input_=input_, d=["x", "y"]) + laplacian(output_=output_, input_=input_, d=["x", "y"], method=method) # Should fail for non-existent output labels with pytest.raises(RuntimeError): - laplacian(output_=output_, input_=input_, components=["a", "b", "c"]) + laplacian( + output_=output_, + input_=input_, + components=["a", "b", "c"], + method=method, + ) def test_advection_scalar(): diff --git a/tests/test_problem_zoo/test_advection.py b/tests/test_problem_zoo/test_advection.py index 4cfc27cd0..e1a656a74 100644 --- a/tests/test_problem_zoo/test_advection.py +++ b/tests/test_problem_zoo/test_advection.py @@ -5,7 +5,7 @@ @pytest.mark.parametrize("c", [1.5, 3]) def test_constructor(c): - print(f"Testing with c = {c} (type: {type(c)})") + problem = AdvectionProblem(c=c) problem.discretise_domain(n=10, mode="random", domains="all") assert problem.are_all_domains_discretised @@ -14,5 +14,6 @@ def test_constructor(c): assert hasattr(problem, "conditions") assert isinstance(problem.conditions, dict) + # Should fail if c is not a float or int with pytest.raises(ValueError): - AdvectionProblem(c="a") + AdvectionProblem(c="invalid") diff --git a/tests/test_problem_zoo/test_allen_cahn.py b/tests/test_problem_zoo/test_allen_cahn.py index 851348077..80c11ce5c 100644 --- a/tests/test_problem_zoo/test_allen_cahn.py +++ b/tests/test_problem_zoo/test_allen_cahn.py @@ -1,12 +1,24 @@ +import pytest from pina.problem.zoo import AllenCahnProblem from pina.problem import SpatialProblem, TimeDependentProblem -def test_constructor(): - problem = AllenCahnProblem() +@pytest.mark.parametrize("alpha", [0.1, 1]) +@pytest.mark.parametrize("beta", [0.1, 1]) +def test_constructor(alpha, beta): + + problem = AllenCahnProblem(alpha=alpha, beta=beta) problem.discretise_domain(n=10, mode="random", domains="all") assert problem.are_all_domains_discretised assert isinstance(problem, SpatialProblem) assert isinstance(problem, TimeDependentProblem) assert hasattr(problem, "conditions") assert isinstance(problem.conditions, dict) + + # Should fail if alpha is not a float or int + with pytest.raises(ValueError): + AllenCahnProblem(alpha="invalid", beta=beta) + + # Should fail if beta is not a float or int + with pytest.raises(ValueError): + AllenCahnProblem(alpha=alpha, beta="invalid") diff --git a/tests/test_problem_zoo/test_diffusion_reaction.py b/tests/test_problem_zoo/test_diffusion_reaction.py index 51709b29c..163d30f55 100644 --- a/tests/test_problem_zoo/test_diffusion_reaction.py +++ b/tests/test_problem_zoo/test_diffusion_reaction.py @@ -1,12 +1,19 @@ +import pytest from pina.problem.zoo import DiffusionReactionProblem from pina.problem import TimeDependentProblem, SpatialProblem -def test_constructor(): - problem = DiffusionReactionProblem() +@pytest.mark.parametrize("alpha", [0.1, 1]) +def test_constructor(alpha): + + problem = DiffusionReactionProblem(alpha=alpha) problem.discretise_domain(n=10, mode="random", domains="all") assert problem.are_all_domains_discretised assert isinstance(problem, TimeDependentProblem) assert isinstance(problem, SpatialProblem) assert hasattr(problem, "conditions") assert isinstance(problem.conditions, dict) + + # Should fail if alpha is not a float or int + with pytest.raises(ValueError): + problem = DiffusionReactionProblem(alpha="invalid") diff --git a/tests/test_problem_zoo/test_helmholtz.py b/tests/test_problem_zoo/test_helmholtz.py index ad8618a06..5e78e4d68 100644 --- a/tests/test_problem_zoo/test_helmholtz.py +++ b/tests/test_problem_zoo/test_helmholtz.py @@ -5,6 +5,7 @@ @pytest.mark.parametrize("alpha", [1.5, 3]) def test_constructor(alpha): + problem = HelmholtzProblem(alpha=alpha) problem.discretise_domain(n=10, mode="random", domains="all") assert problem.are_all_domains_discretised @@ -13,4 +14,4 @@ def test_constructor(alpha): assert isinstance(problem.conditions, dict) with pytest.raises(ValueError): - HelmholtzProblem(alpha="a") + HelmholtzProblem(alpha="invalid") diff --git a/tests/test_problem_zoo/test_inverse_poisson_2d_square.py b/tests/test_problem_zoo/test_inverse_poisson_2d_square.py index 4304c8a5e..423d15d74 100644 --- a/tests/test_problem_zoo/test_inverse_poisson_2d_square.py +++ b/tests/test_problem_zoo/test_inverse_poisson_2d_square.py @@ -1,6 +1,6 @@ +import pytest from pina.problem.zoo import InversePoisson2DSquareProblem from pina.problem import InverseProblem, SpatialProblem -import pytest @pytest.mark.parametrize("load", [True, False]) diff --git a/tests/test_problem_zoo/test_poisson_2d_square.py b/tests/test_problem_zoo/test_poisson_2d_square.py index ed7be0425..a9e6fa973 100644 --- a/tests/test_problem_zoo/test_poisson_2d_square.py +++ b/tests/test_problem_zoo/test_poisson_2d_square.py @@ -3,6 +3,7 @@ def test_constructor(): + problem = Poisson2DSquareProblem() problem.discretise_domain(n=10, mode="random", domains="all") assert problem.are_all_domains_discretised diff --git a/tests/test_solver/test_ensemble_supervised_solver.py b/tests/test_solver/test_ensemble_supervised_solver.py index 45d853fe2..c5f0b9e52 100644 --- a/tests/test_solver/test_ensemble_supervised_solver.py +++ b/tests/test_solver/test_ensemble_supervised_solver.py @@ -2,6 +2,7 @@ import pytest from torch._dynamo.eval_frame import OptimizedModule from torch_geometric.nn import GCNConv +from torch_geometric.utils import to_dense_batch from pina import Condition, LabelTensor from pina.condition import InputTargetCondition from pina.problem import AbstractProblem @@ -82,7 +83,7 @@ def forward(self, batch): y = self.conv(y, edge_index) y = self.activation(y) y = self.output(y) - return y + return to_dense_batch(y, batch.batch)[0] graph_models = [Models() for i in range(10)] diff --git a/tests/test_solver/test_supervised_solver.py b/tests/test_solver/test_supervised_solver.py index 7578acede..6f7d1ab4d 100644 --- a/tests/test_solver/test_supervised_solver.py +++ b/tests/test_solver/test_supervised_solver.py @@ -2,6 +2,7 @@ import pytest from torch._dynamo.eval_frame import OptimizedModule from torch_geometric.nn import GCNConv +from torch_geometric.utils import to_dense_batch from pina import Condition, LabelTensor from pina.condition import InputTargetCondition from pina.problem import AbstractProblem @@ -82,7 +83,7 @@ def forward(self, batch): y = self.conv(y, edge_index) y = self.activation(y) y = self.output(y) - return y + return to_dense_batch(y, batch.batch)[0] graph_model = Model() diff --git a/tests/test_weighting/test_linear_weighting.py b/tests/test_weighting/test_linear_weighting.py new file mode 100644 index 000000000..a11952073 --- /dev/null +++ b/tests/test_weighting/test_linear_weighting.py @@ -0,0 +1,95 @@ +import math +import pytest +from pina import Trainer +from pina.solver import PINN +from pina.model import FeedForward +from pina.loss import LinearWeighting +from pina.problem.zoo import Poisson2DSquareProblem + + +# Initialize problem and model +problem = Poisson2DSquareProblem() +problem.discretise_domain(10) +model = FeedForward(len(problem.input_variables), len(problem.output_variables)) + +# Weights for testing +init_weight_1 = {cond: 3 for cond in problem.conditions.keys()} +init_weight_2 = {cond: 4 for cond in problem.conditions.keys()} +final_weight_1 = {cond: 1 for cond in problem.conditions.keys()} +final_weight_2 = {cond: 5 for cond in problem.conditions.keys()} + + +@pytest.mark.parametrize("initial_weights", [init_weight_1, init_weight_2]) +@pytest.mark.parametrize("final_weights", [final_weight_1, final_weight_2]) +@pytest.mark.parametrize("target_epoch", [5, 10]) +def test_constructor(initial_weights, final_weights, target_epoch): + LinearWeighting( + initial_weights=initial_weights, + final_weights=final_weights, + target_epoch=target_epoch, + ) + + # Should fail if initial_weights is not a dictionary + with pytest.raises(ValueError): + LinearWeighting( + initial_weights=[1, 1, 1], + final_weights=final_weights, + target_epoch=target_epoch, + ) + + # Should fail if final_weights is not a dictionary + with pytest.raises(ValueError): + LinearWeighting( + initial_weights=initial_weights, + final_weights=[1, 1, 1], + target_epoch=target_epoch, + ) + + # Should fail if target_epoch is not an integer + with pytest.raises(AssertionError): + LinearWeighting( + initial_weights=initial_weights, + final_weights=final_weights, + target_epoch=1.5, + ) + + # Should fail if target_epoch is not positive + with pytest.raises(AssertionError): + LinearWeighting( + initial_weights=initial_weights, + final_weights=final_weights, + target_epoch=0, + ) + + # Should fail if dictionary keys do not match + with pytest.raises(ValueError): + LinearWeighting( + initial_weights={list(initial_weights.keys())[0]: 1}, + final_weights=final_weights, + target_epoch=target_epoch, + ) + + +@pytest.mark.parametrize("initial_weights", [init_weight_1, init_weight_2]) +@pytest.mark.parametrize("final_weights", [final_weight_1, final_weight_2]) +@pytest.mark.parametrize("target_epoch", [5, 10]) +def test_train_aggregation(initial_weights, final_weights, target_epoch): + weighting = LinearWeighting( + initial_weights=initial_weights, + final_weights=final_weights, + target_epoch=target_epoch, + ) + solver = PINN(problem=problem, model=model, weighting=weighting) + trainer = Trainer(solver=solver, max_epochs=target_epoch, accelerator="cpu") + trainer.train() + + # Check that weights are updated correctly + assert all( + math.isclose( + weighting.last_saved_weights()[cond], + final_weights[cond], + rel_tol=1e-5, + abs_tol=1e-8, + ) + for cond in final_weights.keys() + ) diff --git a/tests/test_weighting/test_ntk_weighting.py b/tests/test_weighting/test_ntk_weighting.py index 840237fb4..49442b9fb 100644 --- a/tests/test_weighting/test_ntk_weighting.py +++ b/tests/test_weighting/test_ntk_weighting.py @@ -2,64 +2,52 @@ from pina import Trainer from pina.solver import PINN from pina.model import FeedForward -from pina.problem.zoo import Poisson2DSquareProblem from pina.loss import NeuralTangentKernelWeighting +from pina.problem.zoo import Poisson2DSquareProblem + +# Initialize problem and model problem = Poisson2DSquareProblem() -condition_names = problem.conditions.keys() +problem.discretise_domain(10) +model = FeedForward(len(problem.input_variables), len(problem.output_variables)) -@pytest.mark.parametrize( - "model,alpha", - [ - ( - FeedForward( - len(problem.input_variables), len(problem.output_variables) - ), - 0.5, - ) - ], -) -def test_constructor(model, alpha): - NeuralTangentKernelWeighting(model=model, alpha=alpha) +@pytest.mark.parametrize("update_every_n_epochs", [1, 10, 100, 1000]) +@pytest.mark.parametrize("alpha", [0.0, 0.5, 1.0]) +def test_constructor(update_every_n_epochs, alpha): + NeuralTangentKernelWeighting( + update_every_n_epochs=update_every_n_epochs, alpha=alpha + ) + # Should fail if alpha is not >= 0 + with pytest.raises(ValueError): + NeuralTangentKernelWeighting( + update_every_n_epochs=update_every_n_epochs, alpha=-0.1 + ) -@pytest.mark.parametrize("model", [0.5]) -def test_wrong_constructor1(model): + # Should fail if alpha is not <= 1 with pytest.raises(ValueError): - NeuralTangentKernelWeighting(model) + NeuralTangentKernelWeighting(alpha=1.1) + # Should fail if update_every_n_epochs is not an integer + with pytest.raises(AssertionError): + NeuralTangentKernelWeighting(update_every_n_epochs=1.5) -@pytest.mark.parametrize( - "model,alpha", - [ - ( - FeedForward( - len(problem.input_variables), len(problem.output_variables) - ), - 1.2, - ) - ], -) -def test_wrong_constructor2(model, alpha): - with pytest.raises(ValueError): - NeuralTangentKernelWeighting(model, alpha) + # Should fail if update_every_n_epochs is not > 0 + with pytest.raises(AssertionError): + NeuralTangentKernelWeighting(update_every_n_epochs=0) + # Should fail if update_every_n_epochs is not > 0 + with pytest.raises(AssertionError): + NeuralTangentKernelWeighting(update_every_n_epochs=-3) -@pytest.mark.parametrize( - "model,alpha", - [ - ( - FeedForward( - len(problem.input_variables), len(problem.output_variables) - ), - 0.5, - ) - ], -) -def test_train_aggregation(model, alpha): - weighting = NeuralTangentKernelWeighting(model=model, alpha=alpha) - problem.discretise_domain(50) + +@pytest.mark.parametrize("update_every_n_epochs", [1, 3]) +@pytest.mark.parametrize("alpha", [0.0, 0.5, 1.0]) +def test_train_aggregation(update_every_n_epochs, alpha): + weighting = NeuralTangentKernelWeighting( + update_every_n_epochs=update_every_n_epochs, alpha=alpha + ) solver = PINN(problem=problem, model=model, weighting=weighting) trainer = Trainer(solver=solver, max_epochs=5, accelerator="cpu") trainer.train() diff --git a/tests/test_weighting/test_standard_weighting.py b/tests/test_weighting/test_scalar_weighting.py similarity index 62% rename from tests/test_weighting/test_standard_weighting.py rename to tests/test_weighting/test_scalar_weighting.py index 9caa89ae1..bbf71afde 100644 --- a/tests/test_weighting/test_standard_weighting.py +++ b/tests/test_weighting/test_scalar_weighting.py @@ -1,16 +1,17 @@ import pytest import torch - from pina import Trainer from pina.solver import PINN from pina.model import FeedForward -from pina.problem.zoo import Poisson2DSquareProblem from pina.loss import ScalarWeighting +from pina.problem.zoo import Poisson2DSquareProblem + +# Initialize problem and model problem = Poisson2DSquareProblem() +problem.discretise_domain(50) model = FeedForward(len(problem.input_variables), len(problem.output_variables)) condition_names = problem.conditions.keys() -print(problem.conditions.keys()) @pytest.mark.parametrize( @@ -19,25 +20,13 @@ def test_constructor(weights): ScalarWeighting(weights=weights) - -@pytest.mark.parametrize("weights", ["a", [1, 2, 3]]) -def test_wrong_constructor(weights): + # Should fail if weights are not a scalar with pytest.raises(ValueError): - ScalarWeighting(weights=weights) - + ScalarWeighting(weights="invalid") -@pytest.mark.parametrize( - "weights", [1, 1.0, dict(zip(condition_names, [1] * len(condition_names)))] -) -def test_aggregate(weights): - weighting = ScalarWeighting(weights=weights) - losses = dict( - zip( - condition_names, - [torch.randn(1) for _ in range(len(condition_names))], - ) - ) - weighting.aggregate(losses=losses) + # Should fail if weights are not a dictionary + with pytest.raises(ValueError): + ScalarWeighting(weights=[1, 2, 3]) @pytest.mark.parametrize( @@ -45,7 +34,6 @@ def test_aggregate(weights): ) def test_train_aggregation(weights): weighting = ScalarWeighting(weights=weights) - problem.discretise_domain(50) solver = PINN(problem=problem, model=model, weighting=weighting) trainer = Trainer(solver=solver, max_epochs=5, accelerator="cpu") trainer.train() diff --git a/tests/test_weighting/test_self_adaptive_weighting.py b/tests/test_weighting/test_self_adaptive_weighting.py new file mode 100644 index 000000000..066e8855e --- /dev/null +++ b/tests/test_weighting/test_self_adaptive_weighting.py @@ -0,0 +1,39 @@ +import pytest +from pina import Trainer +from pina.solver import PINN +from pina.model import FeedForward +from pina.loss import SelfAdaptiveWeighting +from pina.problem.zoo import Poisson2DSquareProblem + + +# Initialize problem and model +problem = Poisson2DSquareProblem() +problem.discretise_domain(10) +model = FeedForward(len(problem.input_variables), len(problem.output_variables)) + + +@pytest.mark.parametrize("update_every_n_epochs", [10, 100, 1000]) +def test_constructor(update_every_n_epochs): + SelfAdaptiveWeighting(update_every_n_epochs=update_every_n_epochs) + + # Should fail if update_every_n_epochs is not an integer + with pytest.raises(AssertionError): + SelfAdaptiveWeighting(update_every_n_epochs=1.5) + + # Should fail if update_every_n_epochs is not > 0 + with pytest.raises(AssertionError): + SelfAdaptiveWeighting(update_every_n_epochs=0) + + # Should fail if update_every_n_epochs is not > 0 + with pytest.raises(AssertionError): + SelfAdaptiveWeighting(update_every_n_epochs=-3) + + +@pytest.mark.parametrize("update_every_n_epochs", [1, 3]) +def test_train_aggregation(update_every_n_epochs): + weighting = SelfAdaptiveWeighting( + update_every_n_epochs=update_every_n_epochs + ) + solver = PINN(problem=problem, model=model, weighting=weighting) + trainer = Trainer(solver=solver, max_epochs=5, accelerator="cpu") + trainer.train() diff --git a/tutorials/README.md b/tutorials/README.md index e432e4aab..dfbb65116 100644 --- a/tutorials/README.md +++ b/tutorials/README.md @@ -42,6 +42,7 @@ Solving the Kuramoto–Sivashinsky Equation with Averaging Neural Operator |[[.i |---------------|-----------| 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)]| 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)]| diff --git a/tutorials/static/gca_off_on_3_pina.png b/tutorials/static/gca_off_on_3_pina.png new file mode 100644 index 000000000..29f6e099e Binary files /dev/null and b/tutorials/static/gca_off_on_3_pina.png differ diff --git a/tutorials/tutorial11/tutorial.py b/tutorials/tutorial11/tutorial.py index 2ea6e1eae..87ff26aa6 100644 --- a/tutorials/tutorial11/tutorial.py +++ b/tutorials/tutorial11/tutorial.py @@ -3,15 +3,15 @@ # # Tutorial: Introduction to `Trainer` class # [![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) -# -# 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). -# +# +# 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). +# # 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! -# +# # Our leading example will revolve around solving a simple regression problem where we want to approximate the following function with a Neural Net model $\mathcal{M}_{\theta}$: # $$y = x^3$$ # by having only a set of $20$ observations $\{x_i, y_i\}_{i=1}^{20}$, with $x_i \sim\mathcal{U}[-3, 3]\;\;\forall i\in(1,\dots,20)$. -# +# # Let's start by importing useful modules! # In[ ]: @@ -70,16 +70,16 @@ # ## Trainer Accelerator -# +# # When creating the `Trainer`, **by default** the most performing `accelerator` for training which is available in your system will be chosen, ranked as follows: # 1. [TPU](https://cloud.google.com/tpu/docs/intro-to-tpu) # 2. [IPU](https://www.graphcore.ai/products/ipu) # 3. [HPU](https://habana.ai/) # 4. [GPU](https://www.intel.com/content/www/us/en/products/docs/processors/what-is-a-gpu.html#:~:text=What%20does%20GPU%20stand%20for,video%20editing%2C%20and%20gaming%20applications) or [MPS](https://developer.apple.com/metal/pytorch/) # 5. CPU -# +# # For setting manually the `accelerator` run: -# +# # * `accelerator = {'gpu', 'cpu', 'hpu', 'mps', 'cpu', 'ipu'}` sets the accelerator to a specific one # In[15]: @@ -91,11 +91,11 @@ # As you can see, even if a `GPU` is available on the system, it is not used since we set `accelerator='cpu'`. # ## Trainer Logging -# +# # In **PINA** you can log metrics in different ways. The simplest approach is to use the `MetricTracker` class from `pina.callbacks`, as seen in the [*Introduction to Physics Informed Neural Networks training*](https://github.com/mathLab/PINA/blob/master/tutorials/tutorial1/tutorial.ipynb) tutorial. -# +# # 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). -# +# # We will now import `TensorBoardLogger`, do three runs of training, and then visualize the results. Notice we set `enable_model_summary=False` to avoid model summary specifications (e.g. number of parameters); set it to `True` if needed. # In[17]: @@ -133,21 +133,21 @@ #

# As you can see, by default, **PINA** logs the losses which are shown in the progress bar, as well as the number of epochs. You can always insert more loggings by either defining a **callback** ([more on callbacks](https://lightning.ai/docs/pytorch/stable/extensions/callbacks.html)), or inheriting the solver and modifying the programs with different **hooks** ([more on hooks](https://lightning.ai/docs/pytorch/stable/common/lightning_module.html#hooks)). -# +# # ## Trainer Callbacks -# +# # Whenever we need to access certain steps of the training for logging, perform static modifications (i.e. not changing the `Solver`), or update `Problem` hyperparameters (static variables), we can use **Callbacks**. Notice that **Callbacks** allow you to add arbitrary self-contained programs to your training. At specific points during the flow of execution (hooks), the Callback interface allows you to design programs that encapsulate a full set of functionality. It de-couples functionality that does not need to be in **PINA** `Solver`s. -# +# # Lightning has a callback system to execute them when needed. **Callbacks** should capture NON-ESSENTIAL logic that is NOT required for your lightning module to run. -# +# # The following are best practices when using/designing callbacks: -# +# # * Callbacks should be isolated in their functionality. # * Your callback should not rely on the behavior of other callbacks in order to work properly. # * Do not manually call methods from the callback. # * Directly calling methods (e.g., on_validation_end) is strongly discouraged. # * Whenever possible, your callbacks should not depend on the order in which they are executed. -# +# # We will try now to implement a naive version of `MetricTraker` to show how callbacks work. Notice that this is a very easy application of callbacks, fortunately in **PINA** we already provide more advanced callbacks in `pina.callbacks`. # In[18]: @@ -172,7 +172,7 @@ def on_train_epoch_end( # Let's see the results when applied to the problem. You can define **callbacks** when initializing the `Trainer` by using the `callbacks` argument, which expects a list of callbacks. -# +# # In[19]: @@ -206,8 +206,8 @@ def on_train_epoch_end( trainer.callbacks[0].saved_metrics[:3] # only the first three epochs -# PyTorch Lightning also has some built-in `Callbacks` which can be used in **PINA**, [here is an extensive list](https://lightning.ai/docs/pytorch/stable/extensions/callbacks.html#built-in-callbacks). -# +# PyTorch Lightning also has some built-in `Callbacks` which can be used in **PINA**, [here is an extensive list](https://lightning.ai/docs/pytorch/stable/extensions/callbacks.html#built-in-callbacks). +# # We can, for example, try the `EarlyStopping` routine, which automatically stops the training when a specific metric converges (here the `train_loss`). In order to let the training keep going forever, set `max_epochs=-1`. # In[22]: @@ -237,17 +237,17 @@ def on_train_epoch_end( # As we can see the model automatically stop when the logging metric stopped improving! # ## Trainer Tips to Boost Accuracy, Save Memory and Speed Up Training -# +# # Until now we have seen how to choose the right `accelerator`, how to log and visualize the results, and how to interface with the program in order to add specific parts of code at specific points via `callbacks`. # Now, we will focus on how to boost your training by saving memory and speeding it up, while maintaining the same or even better degree of accuracy! -# +# # There are several built-in methods developed in PyTorch Lightning which can be applied straightforward in **PINA**. Here we report some: -# +# # * [Stochastic Weight Averaging](https://pytorch.org/blog/pytorch-1.6-now-includes-stochastic-weight-averaging/) to boost accuracy # * [Gradient Clipping](https://deepgram.com/ai-glossary/gradient-clipping) to reduce computational time (and improve accuracy) # * [Gradient Accumulation](https://lightning.ai/docs/pytorch/stable/common/optimization.html#id3) to save memory consumption # * [Mixed Precision Training](https://lightning.ai/docs/pytorch/stable/common/optimization.html#id3) to save memory consumption -# +# # We will just demonstrate how to use the first two and see the results compared to standard training. # We use the [`Timer`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.callbacks.Timer.html#lightning.pytorch.callbacks.Timer) callback from `pytorch_lightning.callbacks` to track the times. Let's start by training a simple model without any optimization (train for 500 epochs). @@ -312,7 +312,7 @@ def on_train_epoch_end( # As you can see, the training time does not change at all! Notice that around epoch 350 # the scheduler is switched from the defalut one `ConstantLR` to the Stochastic Weight Average Learning Rate (`SWALR`). # This is because by default `StochasticWeightAveraging` will be activated after `int(swa_epoch_start * max_epochs)` with `swa_epoch_start=0.7` by default. Finally, the final `train_loss` is lower when `StochasticWeightAveraging` is used. -# +# # We will now do the same but clippling the gradient to be relatively small. # In[25]: @@ -341,18 +341,18 @@ def on_train_epoch_end( # As we can see, by applying gradient clipping, we were able to achieve even lower error! -# +# # ## What's Next? -# +# # Now you know how to use the `Trainer` class efficiently in **PINA**! There are several directions you can explore next: -# +# # 1. **Explore Training on Different Devices**: Test training times on various devices (e.g., `TPU`) to compare performance. -# +# # 2. **Reduce Memory Costs**: Experiment with mixed precision training and gradient accumulation to optimize memory usage, especially when training Neural Operators. -# +# # 3. **Benchmark `Trainer` Speed**: Benchmark the training speed of the `Trainer` class for different precisions to identify potential optimizations. -# +# # 4. **...and many more!**: Consider expanding to **multi-GPU** setups or other advanced configurations for large-scale training. -# +# # For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/). -# +# diff --git a/tutorials/tutorial14/tutorial.py b/tutorials/tutorial14/tutorial.py index 666d7f72c..f1dc6606f 100644 --- a/tutorials/tutorial14/tutorial.py +++ b/tutorials/tutorial14/tutorial.py @@ -2,11 +2,11 @@ # coding: utf-8 # # Tutorial: Learning Bifurcating PDE Solutions with Physics-Informed Deep Ensembles -# +# # [![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) -# +# # 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). -# +# # Let’s begin by importing the necessary libraries. # In[ ]: @@ -41,62 +41,62 @@ # ## Deep Ensemble -# +# # Deep Ensemble methods improve model performance by leveraging the diversity of predictions generated by multiple neural networks trained on the same problem. Each network in the ensemble is trained independently—typically with different weight initializations or even slight variations in the architecture or data sampling. By combining their outputs (e.g., via averaging or majority voting), ensembles reduce overfitting, increase robustness, and improve generalization. -# +# # This approach allows the ensemble to capture different perspectives of the problem, leading to more accurate and reliable predictions. -# +# #

# Deep ensemble #

-# +# # The image above illustrates a Deep 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. -# -# +# +# # ## Deep Ensemble Physics-Informed Networks -# +# # In the context of Physics-Informed Neural Networks (PINNs), Deep Ensembles help the network discover different branches or multiple solutions of a PDE that exhibits bifurcating behavior. -# +# # By training a diverse set of models with different initializations, Deep Ensemble methods overcome the limitations of single-initialization models, which may converge to only one of the possible solutions. This approach is particularly useful when the solution space of the problem contains multiple valid physical states or behaviors. -# -# +# +# # ## The Bratu Problem -# +# # In this tutorial, we'll train a `DeepEnsemblePINN` solver to solve a bifurcating ODE known as the **Bratu problem**. The ODE is given by: -# +# # $$ # \frac{d^2u}{dt^2} + \lambda e^u = 0, \quad t \in (0, 1) # $$ -# +# # with boundary conditions: -# +# # $$ # u(0) = u(1) = 0, # $$ -# +# # where $\lambda > 0$ is a scalar parameter. The analytical solutions to the 1D Bratu problem can be expressed as: -# +# # $$ # u(t, \alpha) = 2 \log\left(\frac{\cosh(\alpha)}{\cosh(\alpha(1 - 2t))}\right), # $$ -# +# # where $\alpha$ satisfies: -# +# # $$ # \cosh(\alpha) - 2\sqrt{2}\alpha = 0. # $$ -# +# # When $\lambda < 3.513830719$, the equation admits two solutions $\alpha_1$ and $\alpha_2$, which correspond to two distinct solutions of the original ODE: $u_1$ and $u_2$. -# +# # In this tutorial, we set $\lambda = 1$, which leads to: -# +# # - $\alpha_1 \approx 0.37929$ # - $\alpha_2 \approx 2.73468$ -# +# # We first write the problem class, we do not write the boundary conditions as we will hard impose them. -# +# # > **👉 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!** -# +# # > **👉 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!** # In[80]: @@ -135,11 +135,11 @@ class BratuProblem(TimeDependentProblem): # ## Defining the Deep Ensemble Models -# +# # Now that the problem setup is complete, we move on to creating an **ensemble of models**. Each ensemble member will be a standard `FeedForward` neural network, wrapped inside a custom `Model` class. -# +# # Each model's weights are initialized using a **normal distribution** with mean 0 and standard deviation 2. This random initialization is crucial to promote diversity across the ensemble members, allowing the models to converge to potentially different solutions of the PDE. -# +# # The final ensemble is simply a **list of PyTorch models**, which we will later pass to the `DeepEnsemblePINN` # In[81]: @@ -179,15 +179,15 @@ def init_weights_gaussian(self): # As you can see we get different output since the neural networks are initialized differently. -# +# # ## Training with `DeepEnsemblePINN` -# +# # Now that everything is ready, we can train the models using the `DeepEnsemblePINN` solver! 🎯 -# +# # This solver is constructed by combining multiple neural network models that all aim to solve the same PDE. Each model $\mathcal{M}_{i \in \{1, \dots, 10\}}$ in the ensemble contributes a unique perspective due to different random initializations. -# +# # This diversity allows the ensemble to **capture multiple branches or bifurcating solutions** of the problem, making it especially powerful for PDEs like the Bratu problem. -# +# # Once the `DeepEnsemblePINN` solver is defined with all the models, we train them using the `Trainer` class, as with any other solver in **PINA**. We also build a callback to store the value of `u(0.5)` during training iterations. # In[83]: @@ -243,11 +243,11 @@ def on_train_epoch_start(self, trainer, pl_module): # As you can see, different networks in the ensemble converge to different values pf $u(0.5)$ — this means we can actually **spot the bifurcation** in the solution space! -# +# # This is a powerful demonstration of how **Deep Ensemble Physics-Informed Neural Networks** are capable of learning **multiple valid solutions** of a PDE that exhibits bifurcating behavior. -# +# # We can also visualize the ensemble predictions to better observe the multiple branches: -# +# # In[88]: @@ -270,13 +270,13 @@ def on_train_epoch_start(self, trainer, pl_module): # ## What's Next? -# +# # You have completed the tutorial on deep ensemble PINNs for bifurcating PDEs, well don! There are many potential next steps you can explore: -# +# # 1. **Train the network longer or with different hyperparameters**: Experiment with different configurations of the single model, you can compose an ensemble by also stacking models with different layers, activation, ... to improve accuracy. -# +# # 2. **Solve more complex problems**: The original paper provides very complex problems that can be solved with PINA, we suggest you to try implement and solve them! -# +# # 3. **...and many more!**: There are countless directions to further explore, for example, what does it happen when you vary the network initialization hyperparameters? -# +# # For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/). diff --git a/tutorials/tutorial15/tutorial.ipynb b/tutorials/tutorial15/tutorial.ipynb index e4d208401..9e4bacde4 100644 --- a/tutorials/tutorial15/tutorial.ipynb +++ b/tutorials/tutorial15/tutorial.ipynb @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -84,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -93,7 +93,7 @@ "\n", "# save the dataset\n", "input_ = [data for data in dataset]\n", - "target_ = torch.stack([data.y for data in dataset])\n", + "target_ = torch.cat([data.y for data in dataset])\n", "\n", "# normalize the target\n", "mean = target_.mean(dim=0, keepdim=True)\n", @@ -170,6 +170,7 @@ "name": "stderr", "output_type": "stream", "text": [ + "💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.\n", "GPU available: True (mps), used: False\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n" @@ -178,7 +179,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4c17f0dee08d41ef8cf24f8d7f34a245", + "model_id": "8a20671419f04a7787981ecd5d637e4d", "version_major": 2, "version_minor": 0 }, @@ -192,7 +193,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "02a24135327146a7bc4b6b2d3947853c", + "model_id": "6510a166dc954a138f75b5efe11b66a3", "version_major": 2, "version_minor": 0 }, @@ -206,7 +207,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5ab56b75c3bc4c3ea8e093fd07814f8c", + "model_id": "cffe44c9121d420385bc0b9ba109ea34", "version_major": 2, "version_minor": 0 }, @@ -220,7 +221,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "35683edc6c324488aed577e1887fd67f", + "model_id": "d80f65079c884ef3821a9f4aade2959c", "version_major": 2, "version_minor": 0 }, @@ -234,7 +235,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3faa2cd49a874ee3a15292e35a9e2915", + "model_id": "373f2fcb90004e0e9b3fb4fab0636ac9", "version_major": 2, "version_minor": 0 }, @@ -289,7 +290,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f6a0838a82f0459989b0b5327fa44b1c", + "model_id": "87dbeab0063c4a52baf4f0caddcf59a3", "version_major": 2, "version_minor": 0 }, @@ -307,8 +308,7 @@ "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", " Test metric DataLoader 0\n", "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", - " data_loss_epoch 0.3962344825267792\n", - " test_loss_epoch 0.3962344825267792\n", + " test_loss_epoch 0.4040960371494293\n", "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" ] } @@ -392,7 +392,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -401,25 +401,25 @@ "text": [ "Property | Error | Unit\n", "----------------------------------\n", - "μ | 0.7048 | D\n", - "α | 0.4426 | a₀³\n", - "ε HOMO | 0.6538 | eV\n", - "ε LUMO | 0.6223 | eV\n", - "Δε | 0.6431 | eV\n", - "⟨R²⟩ | 0.6322 | a₀²\n", - "ZPVE | 0.2415 | eV\n", - "U₀ | 0.3379 | eV\n", - "U | 0.3387 | eV\n", - "H | 0.3358 | eV\n", - "G | 0.3362 | eV\n", - "cv | 0.5189 | cal/(mol·K)\n", - "U₀ ATOM | 0.2796 | eV\n", - "U ATOM | 0.2795 | eV\n", - "H ATOM | 0.2796 | eV\n", - "G ATOM | 0.2845 | eV\n", - "A | 0.0025 | GHz\n", - "B | 0.2137 | GHz\n", - "C | 0.2083 | GHz\n" + "μ | 0.6893 | D\n", + "α | 0.4544 | a₀³\n", + "ε HOMO | 0.6776 | eV\n", + "ε LUMO | 0.6217 | eV\n", + "Δε | 0.6692 | eV\n", + "⟨R²⟩ | 0.6505 | a₀²\n", + "ZPVE | 0.2475 | eV\n", + "U₀ | 0.3900 | eV\n", + "U | 0.3840 | eV\n", + "H | 0.3804 | eV\n", + "G | 0.3878 | eV\n", + "cv | 0.5486 | cal/(mol·K)\n", + "U₀ ATOM | 0.2869 | eV\n", + "U ATOM | 0.2873 | eV\n", + "H ATOM | 0.2864 | eV\n", + "G ATOM | 0.2901 | eV\n", + "A | 0.0109 | GHz\n", + "B | 0.2072 | GHz\n", + "C | 0.2081 | GHz\n" ] } ], @@ -490,7 +490,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -596,7 +596,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.21" + "version": "3.10.18" } }, "nbformat": 4, diff --git a/tutorials/tutorial15/tutorial.py b/tutorials/tutorial15/tutorial.py index b25b6709c..33e5ae286 100644 --- a/tutorials/tutorial15/tutorial.py +++ b/tutorials/tutorial15/tutorial.py @@ -13,7 +13,7 @@ # # First of all, let's start by importing useful modules! -# In[ ]: +# In[1]: ## routine needed to run the notebook on Google Colab @@ -66,7 +66,7 @@ # | 18 | $C$ | Rotational constant | $GHz$ | # -# In[ ]: +# In[2]: # download the data + shuffling @@ -74,7 +74,7 @@ # save the dataset input_ = [data for data in dataset] -target_ = torch.stack([data.y for data in dataset]) +target_ = torch.cat([data.y for data in dataset]) # normalize the target mean = target_.mean(dim=0, keepdim=True) @@ -185,7 +185,7 @@ def forward(self, data): # As you can see we obtain a tensor with 19 prediction properties as output, which is what we are looking for. Now let's compute the error for each property: -# In[ ]: +# In[9]: properties = [ diff --git a/tutorials/tutorial16/tutorial.ipynb b/tutorials/tutorial16/tutorial.ipynb index ac30c64fc..872f6b6aa 100644 --- a/tutorials/tutorial16/tutorial.ipynb +++ b/tutorials/tutorial16/tutorial.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "014bbd86", "metadata": {}, "outputs": [], @@ -68,7 +68,7 @@ "\n", "We can have two types of problems:\n", "1. ***Data-Driven Problems***: The model is trained using data, such as in classification networks or autoencoders.\n", - "2. **&Physics-Driven Problems***: The model is trained using physical laws representing the problem, such as in **PINNs**.\n", + "2. ***Physics-Driven Problems***: The model is trained using physical laws representing the problem, such as in **PINNs**.\n", "Let's start by building the first type, the data driven type. \n", "\n", "### Data driven modelling\n", @@ -95,7 +95,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "464d4ab2", "metadata": {}, "outputs": [], @@ -131,7 +131,7 @@ "source": [ "You can define as many conditions as needed, and the model will attempt to minimize all of them simultaneously! You can access the data in various ways:\n", "\n", - "- `problem.conditions[''].input`, `problem.conditions[''].output` – Access the input and output data for the specified condition ``.\n", + "- `problem.conditions[''].input`, `problem.conditions[''].target` – Access the input and output data for the specified condition ``.\n", "- `problem.input_pts` – Access the input points for all conditions.\n", "\n", "To ensure that the problem is ready, you can check if all domains have been discretized, meaning all conditions have input points available to pass to the model:" @@ -139,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "5bd8397e", "metadata": {}, "outputs": [ @@ -149,7 +149,7 @@ "True" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -236,7 +236,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "f2608e2e", "metadata": {}, "outputs": [], @@ -290,7 +290,7 @@ "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", "\n", "How are the residuals computed?\n", - "Givem 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://mathlab.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", @@ -317,7 +317,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 5, "id": "a561b984", "metadata": {}, "outputs": [ @@ -327,7 +327,7 @@ "False" ] }, - "execution_count": 16, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -373,7 +373,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 6, "id": "09ce5c3a", "metadata": {}, "outputs": [], @@ -399,7 +399,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 7, "id": "329962b6", "metadata": {}, "outputs": [], @@ -419,7 +419,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 8, "id": "d6ed9aaf", "metadata": {}, "outputs": [ @@ -427,16 +427,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Input points: {'bound_cond': LabelTensor([[0.]]), 'phys_cond': LabelTensor([[0.5744],\n", - " [0.0416],\n", - " [0.6890],\n", - " [0.9406],\n", - " [0.3500]])}\n", - "Input points labels: {'x0': LabelTensor([[0.]]), 'D': LabelTensor([[0.5744],\n", - " [0.0416],\n", - " [0.6890],\n", - " [0.9406],\n", - " [0.3500]])}\n" + "Input points: {'bound_cond': LabelTensor([[0.]]), 'phys_cond': LabelTensor([[0.9117],\n", + " [0.6416],\n", + " [0.3171],\n", + " [0.4330],\n", + " [0.1810]])}\n", + "Input points labels: {'x0': LabelTensor([[0.]]), 'D': LabelTensor([[0.9117],\n", + " [0.6416],\n", + " [0.3171],\n", + " [0.4330],\n", + " [0.1810]])}\n" ] } ], @@ -455,23 +455,23 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 9, "id": "3802e22a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 28, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -503,7 +503,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 10, "id": "c70dfd4b", "metadata": {}, "outputs": [ @@ -554,7 +554,7 @@ ], "metadata": { "kernelspec": { - "display_name": "pina", + "display_name": "deep", "language": "python", "name": "python3" }, @@ -568,7 +568,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.21" + "version": "3.12.11" } }, "nbformat": 4, diff --git a/tutorials/tutorial16/tutorial.py b/tutorials/tutorial16/tutorial.py index 81c9900e3..306ca322d 100644 --- a/tutorials/tutorial16/tutorial.py +++ b/tutorials/tutorial16/tutorial.py @@ -14,7 +14,7 @@ # # By the end of this tutorial, you'll be able to write **data-driven** or **differential problems** in **PINA** and prepare them for model training! -# In[ ]: +# In[1]: ## routine needed to run the notebook on Google Colab @@ -40,7 +40,7 @@ # # We can have two types of problems: # 1. ***Data-Driven Problems***: The model is trained using data, such as in classification networks or autoencoders. -# 2. **&Physics-Driven Problems***: The model is trained using physical laws representing the problem, such as in **PINNs**. +# 2. ***Physics-Driven Problems***: The model is trained using physical laws representing the problem, such as in **PINNs**. # Let's start by building the first type, the data driven type. # # ### Data driven modelling @@ -64,7 +64,7 @@ # # 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: -# In[3]: +# In[2]: from pina import Condition, LabelTensor @@ -93,12 +93,12 @@ class SupervisedProblem(AbstractProblem): # You can define as many conditions as needed, and the model will attempt to minimize all of them simultaneously! You can access the data in various ways: # -# - `problem.conditions[''].input`, `problem.conditions[''].output` – Access the input and output data for the specified condition ``. +# - `problem.conditions[''].input`, `problem.conditions[''].target` – Access the input and output data for the specified condition ``. # - `problem.input_pts` – Access the input points for all conditions. # # To ensure that the problem is ready, you can check if all domains have been discretized, meaning all conditions have input points available to pass to the model: -# In[4]: +# In[3]: # check if all domains are discretised @@ -160,7 +160,7 @@ class SupervisedProblem(AbstractProblem): # Nice, the Problem class is initialized! How to represent the differential equation in **PINA**? To do this, we need to load the **PINA** operators from `pina.operator` module. Again, we'll consider Equation (1) and represent it in **PINA**: -# In[5]: +# In[4]: from pina.problem import SpatialProblem @@ -206,7 +206,7 @@ def solution(self, pts): # 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)). # # How are the residuals computed? -# Givem 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: +# 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: # - A tensor on which the operator is applied. # - A tensor with respect to which the operator is computed. # - The names of the output variables for which the operator is evaluated. @@ -224,7 +224,7 @@ def solution(self, pts): # # When training physics based models, data can come in form of direct numerical simulation results (tensors, graph), or points in the domains which need to be sampled. In case we perform unsupervised learning, we just need the collocation points for training, i.e. points where we want to evaluate the neural network. Sampling point in **PINA** is very easy. But first, let's check if the domains are dicsretized by using the `are_all_domains_discretised` method. -# In[16]: +# In[5]: problem = SimpleODE() @@ -253,7 +253,7 @@ def solution(self, pts): # To discretise the problem you can use the `discretise_domain` method: -# In[25]: +# In[6]: # sampling 20 points in [0, 1] through discretization in all locations @@ -269,7 +269,7 @@ def solution(self, pts): # We are going to use latin hypercube points for sampling. We need to sample in all the conditions domains. In our case we sample in `D` and `x0`. -# In[26]: +# In[7]: # sampling for training @@ -279,7 +279,7 @@ def solution(self, pts): # The points are saved in a python `dict`, and can be accessed by calling the attributes `input_pts` or `discretised_domains` of the problem. -# In[29]: +# In[8]: print("Input points:", problem.input_pts) @@ -288,7 +288,7 @@ def solution(self, pts): # To visualize the sampled points we can use `matplotlib.pyplot`: -# In[28]: +# In[9]: for location in problem.input_pts: @@ -305,7 +305,7 @@ def solution(self, pts): # # Let's see now a physics based example, the advection equation -# In[30]: +# In[10]: from pina.problem.zoo import AdvectionProblem diff --git a/tutorials/tutorial17/tutorial.py b/tutorials/tutorial17/tutorial.py index 7ad946cd7..a1cd74aea 100644 --- a/tutorials/tutorial17/tutorial.py +++ b/tutorials/tutorial17/tutorial.py @@ -2,80 +2,80 @@ # coding: utf-8 # # Tutorial: Introductory Tutorial: A Beginner’s Guide to PINA -# +# # [![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) -# +# #

# PINA logo #

-# -# +# +# # Welcome to **PINA**! -# +# # PINA [1] is an open-source Python library designed for **Scientific Machine Learning (SciML)** tasks, particularly involving: -# +# # - **Physics-Informed Neural Networks (PINNs)** # - **Neural Operators (NOs)** # - **Reduced Order Models (ROMs)** # - **Graph Neural Networks (GNNs)** # - ... -# +# # Built on **PyTorch**, **PyTorch Lightning**, and **PyTorch Geometric**, it provides a **user-friendly, intuitive interface** for formulating and solving differential problems using neural networks. -# +# # This tutorial offers a **step-by-step guide** to using PINA—starting from basic to advanced techniques—enabling users to tackle a broad spectrum of differential problems with minimal code. -# -# -# +# +# +# -# ## The PINA Workflow -# +# ## The PINA Workflow +# #

# PINA Workflow #

-# +# # Solving a differential problem in **PINA** involves four main steps: -# +# # 1. ***Problem & Data*** -# Define the mathematical problem and its physical constraints using PINA’s base classes: +# Define the mathematical problem and its physical constraints using PINA’s base classes: # - `AbstractProblem` # - `SpatialProblem` -# - `InverseProblem` +# - `InverseProblem` # - ... -# +# # Then prepare inputs by discretizing the domain or importing numerical data. PINA provides essential tools like the `Conditions` class and the `pina.domain` module to facilitate domain sampling and ensure that the input data aligns with the problem's requirements. -# +# # > **👉 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!** -# -# 2. ***Model Design*** +# +# 2. ***Model Design*** # 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! -# -# 3. ***Solver Selection*** +# +# 3. ***Solver Selection*** # Choose and configure a solver to optimize your model. Options include: # - **Supervised solvers**: `SupervisedSolver`, `ReducedOrderModelSolver` # - **Physics-informed solvers**: `PINN` and (many) variants -# - **Generative solvers**: `GAROM` +# - **Generative solvers**: `GAROM` # Solvers can be used out-of-the-box, extended, or fully customized. -# -# 4. ***Training*** +# +# 4. ***Training*** # Train your model using the `Trainer` class (built on **PyTorch Lightning**), which enables scalable and efficient training with advanced features. -# -# +# +# # By following these steps, PINA simplifies applying deep learning to scientific computing and differential problems. -# -# +# +# # ## A Simple Regression Problem in PINA # We'll start with a simple regression problem [2] of approximating the following function with a Neural Net model $\mathcal{M}_{\theta}$: -# $$y = x^3 + \epsilon, \quad \epsilon \sim \mathcal{N}(0, 9)$$ -# using only 20 samples: -# +# $$y = x^3 + \epsilon, \quad \epsilon \sim \mathcal{N}(0, 9)$$ +# using only 20 samples: +# # $$x_i \sim \mathcal{U}[-3, 3], \; \forall i \in \{1, \dots, 20\}$$ -# +# # Using PINA, we will: -# +# # - Generate a synthetic dataset. # - Implement a **Bayesian regressor**. # - Use **Monte Carlo (MC) Dropout** for **Bayesian inference** and **uncertainty estimation**. -# +# # This example highlights how PINA can be used for classic regression tasks with probabilistic modeling capabilities. Let's first import useful modules! # In[ ]: @@ -103,14 +103,14 @@ # #### ***Problem & Data*** -# +# # We'll start by defining a `BayesianProblem` inheriting from `AbstractProblem` to handle input/output data. This is suitable when data is available. For other cases like PDEs without data, use: -# +# # - `SpatialProblem` – for spatial variables # - `TimeDependentProblem` – for temporal variables # - `ParametricProblem` – for parametric inputs # - `InverseProblem` – for parameter estimation from observations -# +# # but we will see this more in depth in a while! # In[21]: @@ -140,14 +140,14 @@ class BayesianProblem(AbstractProblem): # We highlight two very important features of PINA -# -# 1. **`LabelTensor` Structure** -# - Alongside the standard `torch.Tensor`, PINA introduces the `LabelTensor` structure, which allows **string-based indexing**. -# - Ideal for managing and stacking tensors with different labels (e.g., `"x"`, `"t"`, `"u"`) for improved clarity and organization. +# +# 1. **`LabelTensor` Structure** +# - Alongside the standard `torch.Tensor`, PINA introduces the `LabelTensor` structure, which allows **string-based indexing**. +# - Ideal for managing and stacking tensors with different labels (e.g., `"x"`, `"t"`, `"u"`) for improved clarity and organization. # - You can still use standard PyTorch tensors if needed. -# -# 2. **`Condition` Object** -# - The `Condition` object enforces the **constraints** that the model $\mathcal{M}_{\theta}$ must satisfy, such as boundary or initial conditions. +# +# 2. **`Condition` Object** +# - The `Condition` object enforces the **constraints** that the model $\mathcal{M}_{\theta}$ must satisfy, such as boundary or initial conditions. # - It ensures that the model adheres to the specific requirements of the problem, making constraint handling more intuitive and streamlined. # In[63]: @@ -168,14 +168,14 @@ class BayesianProblem(AbstractProblem): # #### ***Model Design*** -# -# We will now solve the problem using a **simple PyTorch Neural Network** with **Dropout**, which we will implement from scratch following [2]. +# +# We will now solve the problem using a **simple PyTorch Neural Network** with **Dropout**, which we will implement from scratch following [2]. # 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). -# +# # #### ***Solver Selection*** -# -# For this task, we will use a straightforward **supervised learning** approach by importing the `SupervisedSolver` from `pina.solvers`. The solver is responsible for defining the training strategy. -# +# +# For this task, we will use a straightforward **supervised learning** approach by importing the `SupervisedSolver` from `pina.solvers`. The solver is responsible for defining the training strategy. +# # The `SupervisedSolver` is designed to handle typical regression tasks effectively by minimizing the following loss function: # $$ # \mathcal{L}_{\rm{problem}} = \frac{1}{N}\sum_{i=1}^N @@ -185,14 +185,14 @@ class BayesianProblem(AbstractProblem): # $$ # \mathcal{L}(v) = \| v \|^2_2. # $$ -# +# # #### **Training** -# +# # Next, we will use the `Trainer` class to train the model. The `Trainer` class, based on **PyTorch Lightning**, offers many features that help: # - **Improve model accuracy** # - **Reduce training time and memory usage** -# - **Facilitate logging and visualization** -# +# - **Facilitate logging and visualization** +# # The great work done by the PyTorch Lightning team ensures a streamlined training process. # In[64]: @@ -231,15 +231,15 @@ def forward(self, x): # #### ***Model Training Complete! Now Visualize the Solutions*** -# +# # The model has been trained! Since we used **Dropout** during training, the model is probabilistic (Bayesian) [3]. This means that each time we evaluate the forward pass on the input points $x_i$, the results will differ due to the stochastic nature of Dropout. -# +# # To visualize the model's predictions and uncertainty, we will: -# +# # 1. **Evaluate the Forward Pass**: Perform multiple forward passes to get different predictions for each input $x_i$. # 2. **Compute the Mean**: Calculate the average prediction $\mu_\theta$ across all forward passes. # 3. **Compute the Standard Deviation**: Calculate the variability of the predictions $\sigma_\theta$, which indicates the model's uncertainty. -# +# # This allows us to understand not only the predicted values but also the confidence in those predictions. # In[65]: @@ -267,32 +267,32 @@ def forward(self, x): # ## PINA for Physics-Informed Machine Learning -# +# # In the previous section, we used PINA for **supervised learning**. However, one of its main strengths lies in **Physics-Informed Machine Learning (PIML)**, specifically through **Physics-Informed Neural Networks (PINNs)**. -# +# # ### What Are PINNs? -# +# # PINNs are deep learning models that integrate the laws of physics directly into the training process. By incorporating **differential equations** and **boundary conditions** into the loss function, PINNs allow the modeling of complex physical systems while ensuring the predictions remain consistent with scientific laws. -# +# # ### Solving a 2D Poisson Problem -# +# # In this section, we will solve a **2D Poisson problem** with **Dirichlet boundary conditions** on an **hourglass-shaped domain** using a simple PINN [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: -# +# # $$ # \begin{cases} # \Delta u(x, y) = \sin{(\pi x)} \sin{(\pi y)} & \text{in } D, \\ -# u(x, y) = 0 & \text{on } \partial D +# u(x, y) = 0 & \text{on } \partial D # \end{cases} # $$ -# +# # where $D$ is an **hourglass-shaped domain** defined as the difference between a **Cartesian domain** and two intersecting **ellipsoids**, and $\partial D$ is the boundary of the domain. -# +# # ### Building Complex Domains -# +# # 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`. -# +# # > **👉 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).** -# +# # In[66]: @@ -333,7 +333,7 @@ def forward(self, x): # #### Plotting the domain -# +# # Nice! Now that we have built the domain, let's try to plot it # In[67]: @@ -360,11 +360,11 @@ def forward(self, x): # #### Writing the Poisson Problem Class -# -# Very good! Now we will implement the problem class for the 2D Poisson problem. Unlike the previous examples, where we inherited from `AbstractProblem`, for this problem, we will inherit from the `SpatialProblem` class. -# +# +# Very good! Now we will implement the problem class for the 2D Poisson problem. Unlike the previous examples, where we inherited from `AbstractProblem`, for this problem, we will inherit from the `SpatialProblem` class. +# # The reason for this is that the Poisson problem involves **spatial variables** as input, so we use `SpatialProblem` to handle such cases. -# +# # This will allow us to define the problem with spatial dependencies and set up the neural network model accordingly. # In[69]: @@ -402,12 +402,12 @@ class Poisson(SpatialProblem): # As you can see, writing the problem class for a differential equation in PINA is straightforward! The main differences are: -# +# # - We inherit from **`SpatialProblem`** instead of `AbstractProblem` to account for spatial variables. # - We use **`domain`** and **`equation`** inside the `Condition` to define the problem. -# +# # 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! -# +# # 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 😉. # In[70]: @@ -422,13 +422,13 @@ class Poisson(SpatialProblem): # ### Building the Model -# +# # After setting the problem and sampling the domain, the next step is to **build the model** $\mathcal{M}_{\theta}$. -# +# # 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. -# -# This neural network takes the **coordinates** (in this case `['x', 'y']`) as input and outputs the unknown field of the Poisson problem. -# +# +# This neural network takes the **coordinates** (in this case `['x', 'y']`) as input and outputs the unknown field of the Poisson problem. +# # In this tutorial, the neural network is composed of 2 hidden layers, each with 120 neurons and tanh activation. # In[72]: @@ -445,30 +445,30 @@ class Poisson(SpatialProblem): # ### Solver Selection -# +# # The thir part of the PINA pipeline involves using a **Solver**. -# +# # In this tutorial, we will use the **classical PINN** solver. However, many other variants are also available and we invite to try them! -# +# # #### Loss Function in PINA -# +# # The loss function in the **classical PINN** is defined as follows: -# +# # $$\theta_{\rm{best}}=\min_{\theta}\mathcal{L}_{\rm{problem}}(\theta), \quad \mathcal{L}_{\rm{problem}}(\theta)= \frac{1}{N_{D}}\sum_{i=1}^N # \mathcal{L}(\Delta\mathcal{M}_{\theta}(\mathbf{x}_i, \mathbf{y}_i) - \sin(\pi x_i)\sin(\pi y_i)) + # \frac{1}{N}\sum_{i=1}^N # \mathcal{L}(\mathcal{M}_{\theta}(\mathbf{x}_i, \mathbf{y}_i))$$ -# +# # This loss consists of: # 1. The **differential equation residual**: Ensures the model satisfies the Poisson equation. # 2. The **boundary condition**: Ensures the model satisfies the Dirichlet boundary condition. -# +# # ### Training -# +# # For the last part of the pipeline we need a `Trainer`. We will train the model for **1000 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). -# +# # To track metrics during training, we use the **`MetricTracker`** class. -# +# # > **👉 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).** # In[73]: @@ -527,28 +527,28 @@ class Poisson(SpatialProblem): # ## What's Next? -# +# # Congratulations on completing the introductory tutorial of **PINA**! Now that you have a solid foundation, here are a few directions you can explore: -# +# # 1. **Explore Advanced Solvers**: Dive into more advanced solvers like **SAPINN** or **RBAPINN** and experiment with different variations of Physics-Informed Neural Networks. # 2. **Apply PINA to New Problems**: Try solving other types of differential equations or explore inverse problems and parametric problems using the PINA framework. # 3. **Optimize Model Performance**: Use the `Trainer` class to enhance model performance by exploring features like dynamic learning rates, early stopping, and model checkpoints. -# +# # 4. **...and many more!** — There are countless directions to further explore, from testing on different problems to refining the model architecture! -# +# # For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/). -# -# +# +# # ### References -# +# # [1] *Coscia, Dario, et al. "Physics-informed neural networks for advanced modeling." Journal of Open Source Software, 2023.* -# +# # [2] *Hernández-Lobato, José Miguel, and Ryan Adams. "Probabilistic backpropagation for scalable learning of bayesian neural networks." International conference on machine learning, 2015.* -# +# # [3] *Gal, Yarin, and Zoubin Ghahramani. "Dropout as a bayesian approximation: Representing model uncertainty in deep learning." International conference on machine learning, 2016.* -# +# # [4] *Raissi, Maziar, Paris Perdikaris, and George E. Karniadakis. "Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations." Journal of Computational Physics, 2019.* -# +# # [5] *McClenny, Levi D., and Ulisses M. Braga-Neto. "Self-adaptive physics-informed neural networks." Journal of Computational Physics, 2023.* -# +# # [6] *Anagnostopoulos, Sokratis J., et al. "Residual-based attention in physics-informed neural networks." Computer Methods in Applied Mechanics and Engineering, 2024.* diff --git a/tutorials/tutorial21/tutorial.ipynb b/tutorials/tutorial21/tutorial.ipynb index 69a5f1b20..04acab365 100644 --- a/tutorials/tutorial21/tutorial.ipynb +++ b/tutorials/tutorial21/tutorial.ipynb @@ -6,7 +6,7 @@ "id": "6f71ca5c", "metadata": {}, "source": [ - "# Tutorial: Introductory Tutorial: Supervised Learning with PINA\n", + "# 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", "\n", diff --git a/tutorials/tutorial21/tutorial.py b/tutorials/tutorial21/tutorial.py index 713150b92..5bd9d2cc8 100644 --- a/tutorials/tutorial21/tutorial.py +++ b/tutorials/tutorial21/tutorial.py @@ -1,16 +1,16 @@ #!/usr/bin/env python # coding: utf-8 -# # Tutorial: Introductory Tutorial: Supervised Learning with PINA -# +# # Tutorial: Introductory Tutorial: Neural Operator Learning with PINA +# # [![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) -# -# +# +# # > ##### ⚠️ ***Before starting:*** # > 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. -# +# # 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. -# +# # Let's start by importing the useful modules: # In[ ]: @@ -40,55 +40,55 @@ # ## Learning Differential Operators via Neural Operator -# +# # In this tutorial, we explore how **Neural Operators** can be used to learn and approximate **differential operators**, which are fundamental in modeling physical and engineering systems governed by differential equations. -# +# # ### What Are Neural Operators? -# +# # **Neural Operators (NOs)** are a class of machine learning models designed to learn mappings *between function spaces*, unlike traditional neural networks which learn mappings between finite-dimensional vectors. In the context of differential equations, this means a Neural Operator can learn the **solution operator**: # $$ # \mathcal{G}(a) = u, # $$ # where $a$ is an input function (e.g., a PDE coefficient) and $u$ is the solution function. -# +# # ### Why Are Neural Operators Useful? -# +# # - **Mesh-free learning**: Neural Operators work directly with functions, allowing them to generalize across different spatial resolutions or grids. # - **Fast inference**: Once trained, they can predict the solution of a PDE for new input data almost instantaneously. # - **Physics-aware extensions**: Some variants can incorporate physical laws and constraints into the training process, improving accuracy and generalization. -# +# # ## Learning the 1D Advection Equation with a Neural Operator -# +# # To make things concrete, we'll a Neural Operator to learn the 1D advection equation. We generate synthetic data based on the analytical solution: -# +# # $$ # \frac{\partial u}{\partial t} + c \frac{\partial u}{\partial x} = 0 # $$ -# +# # For a given initial condition $u(x, 0)$, the exact solution at time $t$ is: -# +# # $$ # u(x, t) = u(x - ct) # $$ -# +# # We use this property to generate training data without solving the PDE numerically. -# +# # ### Problem Setup -# +# # 1. **Define the spatial domain**: We work on a 1D grid $x \in [0, 1]$ with periodic boundary conditions. -# +# # 2. **Generate initial conditions**: Each initial condition $u(x, 0)$ is created as a sum of sine waves with random amplitudes and phases: # $$ # u(x, 0) = \sum_{k=1}^K A_k \sin(2\pi k x + \phi_k) # $$ # where $A_k \in [0, 0.5]$ and $\phi_k \in [0, 2\pi]$ are sampled randomly for each sample. -# -# 3. **Compute the solution at time $t$**: +# +# 3. **Compute the solution at time $t$**: # Using the analytical solution, we shift each initial condition by $t=0.5$ ($c=1$), applying periodic wrap-around: # $$ # u(x, t=0.5) = u(x - 0.5) # $$ -# +# # 4. **Create input-output pairs**: The input to the model is the function $u(x, 0)$, and the target output is $u(x, 0.5)$. These pairs can be used to train a Neural Operator to learn the underlying differential operator. # In[18]: @@ -123,59 +123,59 @@ def generate_data(n_samples, x, c=1, t=0.5): # ## Solving the Neural Operator Problem -# +# # 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: -# +# #

# Neural Operators #

-# +# # 1. **Encoder**: The encoder maps the input into a specific embedding space. -# -# 2. **Processor**: The processor consists of multiple layers performing **function convolutions**, which is the core computational unit in a Neural Operator. +# +# 2. **Processor**: The processor consists of multiple layers performing **function convolutions**, which is the core computational unit in a Neural Operator. # 3. **Decoder**: The decoder maps the processor's output back into the desired output space. -# +# # By varying the design and implementation of these three components — encoder, processor, and decoder — different Neural Operators are created, each tailored for specific applications or types of data. -# +# # ### Types of Neural Operators -# +# # Different variants of Neural Operators are designed to solve specific tasks. Some prominent examples include: -# -# - **Fourier Neural Operator (FNO)**: -# 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. +# +# - **Fourier Neural Operator (FNO)**: +# 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. # ➤ [Learn more about FNO](https://mathlab.github.io/PINA/_rst/model/fourier_neural_operator.html). -# -# - **Graph Neural Operator (GNO)**: -# 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. +# +# - **Graph Neural Operator (GNO)**: +# 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. # ➤ [Learn more about GNO](https://mathlab.github.io/PINA/_rst/model/graph_neural_operator.html). -# -# - **Deep Operator Network (DeepONet)**: +# +# - **Deep Operator Network (DeepONet)**: # **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: -# +# # 1. **Branch Network**: Takes the **function inputs** (e.g., $u(x)$) and learns a feature map of the input function. # 2. **Trunk Network**: Takes the **spatial locations** (e.g., $x$) and maps them to the output space. -# -# 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. +# +# 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. # ➤ [Learn more about DeepONet](https://mathlab.github.io/PINA/_rst/model/deeponet.html). -# +# # 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. -# +# # ### KernelNeuralOperator API -# The `KernelNeuralOperator` API requires three parameters: -# +# The `KernelNeuralOperator` API requires three parameters: +# # 1. `lifting_operator`: a `torch.nn.Module` apping the input to its hidden dimension (Encoder). -# +# # 2. `integral_kernels`: a `torch.nn.Module` representing the integral kernels mapping each hidden representation to the next one. -# +# # 3. `projection_operator`: a `torch.nn.Module` representing the hidden representation to the output function. -# +# # 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: -# +# # 1. Define the encoder, a simple linear layer mapping the input dimension to the hidden dimension # 2. Define the decoder, two linear layers mapping the hidden dimension to 128 and back to the input dimension # 3. Define the processor, a two layer Fourier block with a specific hidden dimension. # 4. Combine the encoder-processor-decoder using the `KernelNeuralOperator` API to create the `model`. -# +# # In[23]: @@ -236,9 +236,9 @@ def forward(self, x): # Done! Let's now solve the Neural Operator problem. The problem we will define is a basic `SupervisedProblem`, and we will use the `SupervisedSolver` to train the Neural Operator. -# +# # > **👉 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](http://mathlab.github.io/PINA/_rst/tutorials/tutorial18/tutorial.html) for an overview of Solvers in PINA — have a look if you're interested!** # In[24]: @@ -265,7 +265,7 @@ def forward(self, x): # ## Visualizing the Predictions -# +# # As we can see, we have achieved a very low MSE, even after training for only one epoch. Now, we will visualize the results in the same way as we did previously: # In[30]: @@ -288,15 +288,15 @@ def forward(self, x): # Nice! We can see that the network is correctly learning the solution operator and it was very simple! -# +# # ## What's Next? -# +# # Congratulations on completing the introductory tutorial on Neural Operators! Now that you have a solid foundation, here are a few directions you can explore: -# +# # 1. **Experiment with Training Duration & Network Architecture** — Try different training durations and tweak the network architecture to optimize performance. Choose different integral kernels and see how the results vary. -# +# # 2. **Explore Other Models in `pina.model`** — Check out other models available in `pina.model` or design your own custom PyTorch module to suit your needs. What about trying a `DeepONet`? -# +# # 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. -# +# # For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/). diff --git a/tutorials/tutorial22/holed_poisson.pt b/tutorials/tutorial22/holed_poisson.pt new file mode 100644 index 000000000..c93129a5d Binary files /dev/null and b/tutorials/tutorial22/holed_poisson.pt differ diff --git a/tutorials/tutorial22/tutorial.ipynb b/tutorials/tutorial22/tutorial.ipynb new file mode 100644 index 000000000..8ce4b8ba0 --- /dev/null +++ b/tutorials/tutorial22/tutorial.ipynb @@ -0,0 +1,566 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "6f71ca5c", + "metadata": {}, + "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", + "\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", + "\n", + "In this tutorial, we will demonstrate a typical use case of **PINA** for Reduced Order Modelling using Graph Convolutional Neural Network. The tutorial is largely inspired by the paper [A graph convolutional autoencoder approach to model order reduction for parametrized PDEs](https://www.sciencedirect.com/science/article/pii/S0021999124000111).\n", + "\n", + "Let's start by importing the useful modules:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0981f1e9", + "metadata": {}, + "outputs": [], + "source": [ + "## routine needed to run the notebook on Google Colab\n", + "try:\n", + " import google.colab\n", + "\n", + " IN_COLAB = True\n", + "except:\n", + " 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", + "\n", + "import torch\n", + "from torch import nn\n", + "from torch_geometric.nn import GMMConv\n", + "from torch_geometric.data import (\n", + " Data,\n", + " Batch,\n", + ") # alternatively, from pina.graph import Graph, LabelBatch\n", + "from torch_geometric.utils import to_dense_batch\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "from pina import Trainer\n", + "from pina.model import FeedForward\n", + "from pina.optim import TorchOptimizer\n", + "from pina.solver import ReducedOrderModelSolver\n", + "from pina.problem.zoo import SupervisedProblem" + ] + }, + { + "cell_type": "markdown", + "id": "c04276af", + "metadata": {}, + "source": [ + "## Data Generation\n", + "\n", + "In this tutorial, we will focus on solving the parametric **Poisson** equation, a linear PDE. The equation is given by:\n", + "\n", + "$$\n", + "\\begin{cases}\n", + "-\\frac{1}{10}\\Delta u = 1, &\\Omega(\\boldsymbol{\\mu}),\\\\\n", + "u = 0, &\\partial \\Omega(\\boldsymbol{\\mu}).\n", + "\\end{cases}\n", + "$$\n", + "\n", + "In this equation, $\\Omega(\\boldsymbol{\\mu}) = [0, 1]\\times[0,1] \\setminus [\\mu_1, \\mu_2]\\times[\\mu_1+0.3, \\mu_2+0.3]$ represents the spatial domain characterized by a parametrized hole defined via $\\boldsymbol{\\mu} = (\\mu_1, \\mu_2) \\in \\mathbb{P} = [0.1, 0.6]\\times[0.1, 0.6]$. Thus, the geometrical parameters define the left bottom corner of a square obstacle of dimension $0.3$. The problem is coupled with homogenous Dirichlet conditions on both internal and external boundaries. In this setting, $u(\\mathbf{x}, \\boldsymbol{\\mu})\\in \\mathbb{R}$ is the value of the function $u$ at each point in space for a specific parameter $\\boldsymbol{\\mu}$. \n", + "\n", + "We have already generated data for different parameters. The dataset is obtained via $\\mathbb{P}^1$ FE method, and an equispaced sampling with 11 points in each direction of the parametric space. \n", + "\n", + "The goal is to build a Reduced Order Model that given a new parameter $\\boldsymbol{\\mu}^*$, is able to get the solution $u$ *for any discretization* $\\mathbf{x}$. To this end, we will train a Graph Convolutional Autoencoder Reduced Order Model (GCA-ROM), as presented in [A graph convolutional autoencoder approach to model order reduction for parametrized PDEs](https://www.sciencedirect.com/science/article/pii/S0021999124000111). We will cover the architecture details later, but for now, let’s start by importing the data.\n", + "\n", + "**Note:**\n", + "The numerical integration is obtained using a finite element method with the [RBniCS library](https://www.rbnicsproject.org/)." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "9cbfd29d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# === load the data ===\n", + "# x, y -> spatial discretization\n", + "# edge_index, triang -> connectivity matrix, triangulation\n", + "# u, params -> solution field, parameters\n", + "\n", + "data = torch.load(\"holed_poisson.pt\")\n", + "x = data[\"x\"]\n", + "y = data[\"y\"]\n", + "edge_index = data[\"edge_index\"]\n", + "u = data[\"u\"]\n", + "triang = data[\"triang\"]\n", + "params = data[\"mu\"]\n", + "\n", + "# simple plot\n", + "plt.figure(figsize=(4, 4))\n", + "plt.tricontourf(x[:, 10], y[:, 10], triang, u[:, 10], 100, cmap=\"jet\")\n", + "plt.scatter(params[10, 0], params[10, 1], c=\"r\", marker=\"x\", s=100)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f3619e4f", + "metadata": {}, + "source": [ + "## Graph-Based Reduced Order Modeling\n", + "\n", + "In this problem, the geometry of the spatial domain is **unstructured**, meaning that classical grid-based methods (e.g., CNNs) are not well suited. Instead, we represent the mesh as a **graph**, where nodes correspond to spatial degrees of freedom and edges represent connectivity. This makes **Graph Neural Networks (GNNs)**, and in particular **Graph Convolutional Networks (GCNs)**, a natural choice to process the data.\n", + "\n", + "

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

\n", + "\n", + "To reduce computational complexity while preserving accuracy, we employ a **Reduced Order Modeling (ROM)** strategy (see picture above). The idea is to map high-dimensional simulation data $u(\\mathbf{x}, \\boldsymbol{\\mu})$ to a compact **latent space** using a **graph convolutional encoder**, and then reconstruct it back via a **decoder** (offline phase). The latent representation captures the essential features of the solution manifold. Moreover, we can learn a **parametric map** $\\mathcal{M}$ from the parameter space $\\boldsymbol{\\mu}$ directly into the latent space, enabling predictions for new unseen parameters.\n", + "\n", + "Formally, the autoencoder consists of an **encoder** $\\mathcal{E}$, a **decoder** $\\mathcal{D}$, and a **parametric mapping** $\\mathcal{M}$:\n", + "$$\n", + "z = \\mathcal{E}(u(\\mathbf{x}, \\boldsymbol{\\mu})), \n", + "\\quad\n", + "\\hat{u}(\\mathbf{x}, \\boldsymbol{\\mu}) = \\mathcal{D}(z),\n", + "\\quad\n", + "\\hat{z} = \\mathcal{M}(\\boldsymbol{\\mu}),\n", + "$$\n", + "where $z \\in \\mathbb{R}^r$ is the latent representation with $r \\ll N$ (the number of degrees of freedom) and the **hat notation** ($\\hat{u}, \\hat{z}$) indicates *learned or approximated quantities*.\n", + "\n", + "The training objective balances two terms:\n", + "1. **Reconstruction loss**: ensuring the autoencoder can faithfully reconstruct $u$ from $z$.\n", + "2. **Latent consistency loss**: enforcing that the parametric map $\\mathcal{M}(\\boldsymbol{\\mu})$ approximates the encoder’s latent space.\n", + "\n", + "The combined loss function is:\n", + "$$\n", + "\\mathcal{L}(\\theta) = \\frac{1}{N} \\sum_{i=1}^N \n", + "\\big\\| u(\\mathbf{x}, \\boldsymbol{\\mu}_i) - \n", + "\\mathcal{D}\\!\\big(\\mathcal{E}(u(\\mathbf{x}, \\boldsymbol{\\mu}_i))\\big) \n", + "\\big\\|_2^2\n", + "\\;+\\; \\frac{1}{N} \\sum_{i=1}^N\n", + "\\big\\| \\mathcal{E}(u(\\mathbf{x}, \\boldsymbol{\\mu}_i)) - \\mathcal{M}(\\boldsymbol{\\mu}_i) \\big\\|_2^2.\n", + "$$\n", + "This framework leverages the expressive power of GNNs for unstructured geometries and the efficiency of ROMs for handling parametric PDEs.\n", + "\n", + "We will now build the autoencoder network, which is a `nn.Module` with two methods: `encode` and `decode`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3197831b", + "metadata": {}, + "outputs": [], + "source": [ + "class GraphConvolutionalAutoencoder(nn.Module):\n", + " def __init__(\n", + " self, hidden_channels, bottleneck, input_size, ffn, act=nn.ELU\n", + " ):\n", + " super().__init__()\n", + " self.hidden_channels, self.input_size = hidden_channels, input_size\n", + " self.act = act()\n", + " self.current_graph = None\n", + "\n", + " # Encoder GMM layers\n", + " self.fc_enc1 = nn.Linear(input_size * hidden_channels[-1], ffn)\n", + " self.fc_enc2 = nn.Linear(ffn, bottleneck)\n", + " self.encoder_convs = nn.ModuleList(\n", + " [\n", + " GMMConv(\n", + " hidden_channels[i],\n", + " hidden_channels[i + 1],\n", + " dim=1,\n", + " kernel_size=5,\n", + " )\n", + " for i in range(len(hidden_channels) - 1)\n", + " ]\n", + " )\n", + " # Decoder GMM layers\n", + " self.fc_dec1 = nn.Linear(bottleneck, ffn)\n", + " self.fc_dec2 = nn.Linear(ffn, input_size * hidden_channels[-1])\n", + " self.decoder_convs = nn.ModuleList(\n", + " [\n", + " GMMConv(\n", + " hidden_channels[-i - 1],\n", + " hidden_channels[-i - 2],\n", + " dim=1,\n", + " kernel_size=5,\n", + " )\n", + " for i in range(len(hidden_channels) - 1)\n", + " ]\n", + " )\n", + "\n", + " def encode(self, data):\n", + " self.current_graph = data\n", + " x = data.x\n", + " h = x\n", + " for conv in self.encoder_convs:\n", + " x = self.act(conv(x, data.edge_index, data.edge_weight) + h)\n", + " x = x.reshape(\n", + " data.num_graphs, self.input_size * self.hidden_channels[-1]\n", + " )\n", + " return self.fc_enc2(self.act(self.fc_enc1(x)))\n", + "\n", + " def decode(self, z, decoding_graph=None):\n", + " data = decoding_graph or self.current_graph\n", + " x = self.act(self.fc_dec2(self.act(self.fc_dec1(z)))).reshape(\n", + " data.num_graphs * self.input_size, self.hidden_channels[-1]\n", + " )\n", + " h = x\n", + " for i, conv in enumerate(self.decoder_convs):\n", + " x = conv(x, data.edge_index, data.edge_weight) + h\n", + " if i != len(self.decoder_convs) - 1:\n", + " x = self.act(x)\n", + " return x" + ] + }, + { + "cell_type": "markdown", + "id": "4d14d91d", + "metadata": {}, + "source": [ + "Great! We now need to build the graph structure (a PyTorch Geometric `Data` object) from the numerical solver outputs.\n", + "\n", + "The solver provides the solution values $u(\\mathbf{x}, \\boldsymbol{\\mu})$ for each parameter instance $\\boldsymbol{\\mu}$, along with the node coordinates $(x, y)$ of the unstructured mesh. Because the geometry is not defined on a regular grid, we naturally represent the mesh as a graph:\n", + "\n", + "- **Nodes** correspond to spatial points in the mesh. Each node stores the **solution value** $u$ at that point as a feature. \n", + "- **Edges** represent mesh connectivity. For each edge, we compute:\n", + " - **Edge attributes**: the relative displacement vector between the two nodes. \n", + " - **Edge weights**: the Euclidean distance between the connected nodes. \n", + "- **Positions** store the physical $(x, y)$ coordinates of the nodes.\n", + "\n", + "For each parameter realization $\\boldsymbol{\\mu}_i$, we therefore construct a PyTorch Geometric `Data` object:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8f098b6d", + "metadata": {}, + "outputs": [], + "source": [ + "# number of nodes and number of graphs (parameter realizations)\n", + "num_nodes, num_graphs = u.shape\n", + "\n", + "graphs = []\n", + "for g in range(num_graphs):\n", + " # node positions\n", + " pos = torch.stack([x[:, g], y[:, g]], dim=1) # shape [num_nodes, 2]\n", + " # edge attributes and weights\n", + " ei, ej = pos[edge_index[0]], pos[edge_index[1]] # [num_edges, 2]\n", + " edge_attr = torch.abs(ej - ei) # relative offsets\n", + " edge_weight = edge_attr.norm(p=2, dim=1, keepdim=True) # Euclidean distance\n", + " # node features (solution values)\n", + " node_features = u[:, g].unsqueeze(-1) # [num_nodes, 1]\n", + " # build PyG graph\n", + " graphs.append(\n", + " Data(\n", + " x=node_features,\n", + " edge_index=edge_index,\n", + " edge_weight=edge_weight,\n", + " edge_attr=edge_attr,\n", + " pos=pos,\n", + " )\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "e38ad2d8", + "metadata": {}, + "source": [ + "## Training with PINA\n", + "\n", + "Everything is now ready! We can use **PINA** to train the model, following the workflow from previous tutorials. 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", + "\n", + "- **Input**: the parameter tensor $\\boldsymbol{\\mu}$ describing each scenario. \n", + "- **Output**: the corresponding graph structure (PyTorch Geometric `Data` object) that we aim to reconstruct. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "bbb3f90f", + "metadata": {}, + "outputs": [], + "source": [ + "problem = SupervisedProblem(params, graphs)" + ] + }, + { + "cell_type": "markdown", + "id": "79875c61", + "metadata": {}, + "source": [ + "Next, we build the **autoencoder network** and the **interpolation network**. \n", + "\n", + "- The **Graph Convolutional Autoencoder (GCA)** encodes the high-dimensional graph data into a compact latent space and reconstructs the graphs from this latent representation. \n", + "- The **interpolation network** (or parametric map) learns to map a new parameter $\\boldsymbol{\\mu}^*$ directly into the latent space, enabling the model to predict solutions for unseen parameter instances without running the full encoder." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "601b8b11", + "metadata": {}, + "outputs": [], + "source": [ + "reduction_network = GraphConvolutionalAutoencoder(\n", + " hidden_channels=[1, 1], bottleneck=8, input_size=1352, ffn=200, act=nn.ELU\n", + ")\n", + "interpolation_network = FeedForward(\n", + " input_dimensions=2,\n", + " output_dimensions=8,\n", + " n_layers=2,\n", + " inner_size=200,\n", + " func=nn.Tanh,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "45f2d8b9", + "metadata": {}, + "source": [ + "Finally, we will use the [`ReducedOrderModelSolver`](https://mathlab.github.io/PINA/_rst/solver/supervised_solver/reduced_order_model.html#pina.solver.supervised_solver.reduced_order_model.ReducedOrderModelSolver) to perform the training, as discussed earlier. \n", + "\n", + "This solver requires two components: \n", + "- an **interpolation network**, which maps parameters $\\boldsymbol{\\mu}$ to the latent space, and \n", + "- a **reduction network**, which in our case is the **autoencoder** that compresses and reconstructs the graph data. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "47a02df1", + "metadata": {}, + "outputs": [], + "source": [ + "# This loss handles both Data and Torch.Tensors\n", + "class CustomMSELoss(nn.MSELoss):\n", + " def forward(self, output, target):\n", + " if isinstance(output, Data):\n", + " output = output.x\n", + " if isinstance(target, Data):\n", + " target = target.x\n", + " return torch.nn.functional.mse_loss(\n", + " output, target, reduction=self.reduction\n", + " )\n", + "\n", + "\n", + "# Define the solver\n", + "solver = ReducedOrderModelSolver(\n", + " problem=problem,\n", + " reduction_network=reduction_network,\n", + " interpolation_network=interpolation_network,\n", + " use_lt=False,\n", + " loss=CustomMSELoss(),\n", + " optimizer=TorchOptimizer(torch.optim.Adam, lr=0.001, weight_decay=1e-05),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "063b118a", + "metadata": {}, + "source": [ + "Training is performed as usual using the **`Trainer`** API. In this tutorial, we will use only **30% of the data** for training, and only $300$ epochs of training to illustrate the workflow." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7081ca73", + "metadata": {}, + "outputs": [], + "source": [ + "trainer = Trainer(\n", + " solver=solver,\n", + " accelerator=\"cpu\",\n", + " max_epochs=300,\n", + " train_size=0.3,\n", + " val_size=0.7,\n", + " test_size=0.0,\n", + " shuffle=True,\n", + ")\n", + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "id": "b1d11289", + "metadata": {}, + "source": [ + "Once the model is trained, we can test the reconstruction by following two steps:\n", + "\n", + "1. **Interpolate**: Use the `interpolation_network` to map a new parameter $\\boldsymbol{\\mu}^*$ to the latent space. \n", + "2. **Decode**: Pass the interpolated latent vector through the autoencoder (`reduction_network`) to reconstruct the corresponding graph data." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8dd5c0d4", + "metadata": {}, + "outputs": [], + "source": [ + "# interpolate\n", + "z = interpolation_network(params)\n", + "\n", + "# decode\n", + "batch = Batch.from_data_list(graphs)\n", + "out = reduction_network.decode(z, decoding_graph=batch)\n", + "out, _ = to_dense_batch(out, batch.batch)\n", + "out = out.squeeze(-1).T.detach()" + ] + }, + { + "cell_type": "markdown", + "id": "91685b70", + "metadata": {}, + "source": [ + "Let's compute the total error, and plot a sample solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "29d3dbac", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "L2 relative error 6.90%\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# compute error\n", + "l2_error = (torch.norm(out - u, dim=0) / torch.norm(u, dim=0)).mean()\n", + "print(f\"L2 relative error {l2_error:.2%}\")\n", + "\n", + "# plot solution\n", + "idx_to_plot = 42\n", + "# Determine min and max values for color scaling\n", + "vmin = min(out[:, idx_to_plot].min(), u[:, idx_to_plot].min())\n", + "vmax = max(out[:, idx_to_plot].max(), u[:, idx_to_plot].max())\n", + "plt.figure(figsize=(16, 4))\n", + "plt.subplot(1, 3, 1)\n", + "plt.tricontourf(\n", + " x[:, idx_to_plot],\n", + " y[:, idx_to_plot],\n", + " triang,\n", + " out[:, idx_to_plot],\n", + " 100,\n", + " cmap=\"jet\",\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + ")\n", + "plt.title(\"GCA-ROM\")\n", + "plt.colorbar()\n", + "plt.subplot(1, 3, 2)\n", + "plt.title(\"True\")\n", + "plt.tricontourf(\n", + " x[:, idx_to_plot],\n", + " y[:, idx_to_plot],\n", + " triang,\n", + " u[:, idx_to_plot],\n", + " 100,\n", + " cmap=\"jet\",\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + ")\n", + "plt.colorbar()\n", + "plt.subplot(1, 3, 3)\n", + "plt.title(\"Square Error\")\n", + "plt.tricontourf(\n", + " x[:, idx_to_plot],\n", + " y[:, idx_to_plot],\n", + " triang,\n", + " (u - out).pow(2)[:, idx_to_plot],\n", + " 100,\n", + " cmap=\"jet\",\n", + ")\n", + "plt.colorbar()\n", + "plt.ticklabel_format()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c152bfd1", + "metadata": {}, + "source": [ + "Nice! We can see that the network is correctly learning the solution operator, and the workflow was very straightforward. \n", + "\n", + "You may notice that the network outputs are not as smooth as the actual solution. Don’t worry — training for longer (e.g., ~5000 epochs) will produce a smoother, more accurate reconstruction.\n", + "\n", + "## What's Next?\n", + "\n", + "Congratulations on completing the introductory tutorial on **Graph Convolutional Reduced Order Modeling**! Now that you have a solid foundation, here are a few directions to explore:\n", + "\n", + "1. **Experiment with Training Duration** — Try different training durations and adjust the network architecture to optimize performance. Explore different integral kernels and observe how the results vary.\n", + "\n", + "2. **Explore Physical Constraints** — Incorporate physics-informed terms or constraints during training to improve model generalization and ensure physically consistent predictions.\n", + "\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/)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pina", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/tutorial22/tutorial.py b/tutorials/tutorial22/tutorial.py new file mode 100644 index 000000000..6c2fae659 --- /dev/null +++ b/tutorials/tutorial22/tutorial.py @@ -0,0 +1,409 @@ +#!/usr/bin/env python +# coding: utf-8 + +# # Tutorial: Reduced Order Model with Graph Neural Networks +# +# [![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) +# +# +# > ##### ⚠️ ***Before starting:*** +# > 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. +# +# In this tutorial, we will demonstrate a typical use case of **PINA** for Reduced Order Modelling using Graph Convolutional Neural Network. The tutorial is largely inspired by the paper [A graph convolutional autoencoder approach to model order reduction for parametrized PDEs](https://www.sciencedirect.com/science/article/pii/S0021999124000111). +# +# Let's start by importing the useful modules: + +# In[ ]: + + +## routine needed to run the notebook on Google Colab +try: + import google.colab + + IN_COLAB = True +except: + IN_COLAB = False +if IN_COLAB: + get_ipython().system('pip install "pina-mathlab[tutorial]"') + get_ipython().system('wget "https://github.com/mathLab/PINA/raw/refs/heads/master/tutorials/tutorial22/holed_poisson.pt" -O "holed_poisson.pt"') + +import torch +from torch import nn +from torch_geometric.nn import GMMConv +from torch_geometric.data import ( + Data, + Batch, +) # alternatively, from pina.graph import Graph, LabelBatch +from torch_geometric.utils import to_dense_batch + +import matplotlib.pyplot as plt +import warnings + +warnings.filterwarnings("ignore") + +from pina import Trainer +from pina.model import FeedForward +from pina.optim import TorchOptimizer +from pina.solver import ReducedOrderModelSolver +from pina.problem.zoo import SupervisedProblem + + +# ## Data Generation +# +# In this tutorial, we will focus on solving the parametric **Poisson** equation, a linear PDE. The equation is given by: +# +# $$ +# \begin{cases} +# -\frac{1}{10}\Delta u = 1, &\Omega(\boldsymbol{\mu}),\\ +# u = 0, &\partial \Omega(\boldsymbol{\mu}). +# \end{cases} +# $$ +# +# In this equation, $\Omega(\boldsymbol{\mu}) = [0, 1]\times[0,1] \setminus [\mu_1, \mu_2]\times[\mu_1+0.3, \mu_2+0.3]$ represents the spatial domain characterized by a parametrized hole defined via $\boldsymbol{\mu} = (\mu_1, \mu_2) \in \mathbb{P} = [0.1, 0.6]\times[0.1, 0.6]$. Thus, the geometrical parameters define the left bottom corner of a square obstacle of dimension $0.3$. The problem is coupled with homogenous Dirichlet conditions on both internal and external boundaries. In this setting, $u(\mathbf{x}, \boldsymbol{\mu})\in \mathbb{R}$ is the value of the function $u$ at each point in space for a specific parameter $\boldsymbol{\mu}$. +# +# We have already generated data for different parameters. The dataset is obtained via $\mathbb{P}^1$ FE method, and an equispaced sampling with 11 points in each direction of the parametric space. +# +# The goal is to build a Reduced Order Model that given a new parameter $\boldsymbol{\mu}^*$, is able to get the solution $u$ *for any discretization* $\mathbf{x}$. To this end, we will train a Graph Convolutional Autoencoder Reduced Order Model (GCA-ROM), as presented in [A graph convolutional autoencoder approach to model order reduction for parametrized PDEs](https://www.sciencedirect.com/science/article/pii/S0021999124000111). We will cover the architecture details later, but for now, let’s start by importing the data. +# +# **Note:** +# The numerical integration is obtained using a finite element method with the [RBniCS library](https://www.rbnicsproject.org/). + +# In[21]: + + +# === load the data === +# x, y -> spatial discretization +# edge_index, triang -> connectivity matrix, triangulation +# u, params -> solution field, parameters + +data = torch.load("holed_poisson.pt") +x = data["x"] +y = data["y"] +edge_index = data["edge_index"] +u = data["u"] +triang = data["triang"] +params = data["mu"] + +# simple plot +plt.figure(figsize=(4, 4)) +plt.tricontourf(x[:, 10], y[:, 10], triang, u[:, 10], 100, cmap="jet") +plt.scatter(params[10, 0], params[10, 1], c="r", marker="x", s=100) +plt.tight_layout() +plt.show() + + +# ## Graph-Based Reduced Order Modeling +# +# In this problem, the geometry of the spatial domain is **unstructured**, meaning that classical grid-based methods (e.g., CNNs) are not well suited. Instead, we represent the mesh as a **graph**, where nodes correspond to spatial degrees of freedom and edges represent connectivity. This makes **Graph Neural Networks (GNNs)**, and in particular **Graph Convolutional Networks (GCNs)**, a natural choice to process the data. +# +#

+# GCA-ROM +#

+# +# To reduce computational complexity while preserving accuracy, we employ a **Reduced Order Modeling (ROM)** strategy (see picture above). The idea is to map high-dimensional simulation data $u(\mathbf{x}, \boldsymbol{\mu})$ to a compact **latent space** using a **graph convolutional encoder**, and then reconstruct it back via a **decoder** (offline phase). The latent representation captures the essential features of the solution manifold. Moreover, we can learn a **parametric map** $\mathcal{M}$ from the parameter space $\boldsymbol{\mu}$ directly into the latent space, enabling predictions for new unseen parameters. +# +# Formally, the autoencoder consists of an **encoder** $\mathcal{E}$, a **decoder** $\mathcal{D}$, and a **parametric mapping** $\mathcal{M}$: +# $$ +# z = \mathcal{E}(u(\mathbf{x}, \boldsymbol{\mu})), +# \quad +# \hat{u}(\mathbf{x}, \boldsymbol{\mu}) = \mathcal{D}(z), +# \quad +# \hat{z} = \mathcal{M}(\boldsymbol{\mu}), +# $$ +# where $z \in \mathbb{R}^r$ is the latent representation with $r \ll N$ (the number of degrees of freedom) and the **hat notation** ($\hat{u}, \hat{z}$) indicates *learned or approximated quantities*. +# +# The training objective balances two terms: +# 1. **Reconstruction loss**: ensuring the autoencoder can faithfully reconstruct $u$ from $z$. +# 2. **Latent consistency loss**: enforcing that the parametric map $\mathcal{M}(\boldsymbol{\mu})$ approximates the encoder’s latent space. +# +# The combined loss function is: +# $$ +# \mathcal{L}(\theta) = \frac{1}{N} \sum_{i=1}^N +# \big\| u(\mathbf{x}, \boldsymbol{\mu}_i) - +# \mathcal{D}\!\big(\mathcal{E}(u(\mathbf{x}, \boldsymbol{\mu}_i))\big) +# \big\|_2^2 +# \;+\; \frac{1}{N} \sum_{i=1}^N +# \big\| \mathcal{E}(u(\mathbf{x}, \boldsymbol{\mu}_i)) - \mathcal{M}(\boldsymbol{\mu}_i) \big\|_2^2. +# $$ +# This framework leverages the expressive power of GNNs for unstructured geometries and the efficiency of ROMs for handling parametric PDEs. +# +# We will now build the autoencoder network, which is a `nn.Module` with two methods: `encode` and `decode`. +# + +# In[3]: + + +class GraphConvolutionalAutoencoder(nn.Module): + def __init__( + self, hidden_channels, bottleneck, input_size, ffn, act=nn.ELU + ): + super().__init__() + self.hidden_channels, self.input_size = hidden_channels, input_size + self.act = act() + self.current_graph = None + + # Encoder GMM layers + self.fc_enc1 = nn.Linear(input_size * hidden_channels[-1], ffn) + self.fc_enc2 = nn.Linear(ffn, bottleneck) + self.encoder_convs = nn.ModuleList( + [ + GMMConv( + hidden_channels[i], + hidden_channels[i + 1], + dim=1, + kernel_size=5, + ) + for i in range(len(hidden_channels) - 1) + ] + ) + # Decoder GMM layers + self.fc_dec1 = nn.Linear(bottleneck, ffn) + self.fc_dec2 = nn.Linear(ffn, input_size * hidden_channels[-1]) + self.decoder_convs = nn.ModuleList( + [ + GMMConv( + hidden_channels[-i - 1], + hidden_channels[-i - 2], + dim=1, + kernel_size=5, + ) + for i in range(len(hidden_channels) - 1) + ] + ) + + def encode(self, data): + self.current_graph = data + x = data.x + h = x + for conv in self.encoder_convs: + x = self.act(conv(x, data.edge_index, data.edge_weight) + h) + x = x.reshape( + data.num_graphs, self.input_size * self.hidden_channels[-1] + ) + return self.fc_enc2(self.act(self.fc_enc1(x))) + + def decode(self, z, decoding_graph=None): + data = decoding_graph or self.current_graph + x = self.act(self.fc_dec2(self.act(self.fc_dec1(z)))).reshape( + data.num_graphs * self.input_size, self.hidden_channels[-1] + ) + h = x + for i, conv in enumerate(self.decoder_convs): + x = conv(x, data.edge_index, data.edge_weight) + h + if i != len(self.decoder_convs) - 1: + x = self.act(x) + return x + + +# Great! We now need to build the graph structure (a PyTorch Geometric `Data` object) from the numerical solver outputs. +# +# The solver provides the solution values $u(\mathbf{x}, \boldsymbol{\mu})$ for each parameter instance $\boldsymbol{\mu}$, along with the node coordinates $(x, y)$ of the unstructured mesh. Because the geometry is not defined on a regular grid, we naturally represent the mesh as a graph: +# +# - **Nodes** correspond to spatial points in the mesh. Each node stores the **solution value** $u$ at that point as a feature. +# - **Edges** represent mesh connectivity. For each edge, we compute: +# - **Edge attributes**: the relative displacement vector between the two nodes. +# - **Edge weights**: the Euclidean distance between the connected nodes. +# - **Positions** store the physical $(x, y)$ coordinates of the nodes. +# +# For each parameter realization $\boldsymbol{\mu}_i$, we therefore construct a PyTorch Geometric `Data` object: +# + +# In[4]: + + +# number of nodes and number of graphs (parameter realizations) +num_nodes, num_graphs = u.shape + +graphs = [] +for g in range(num_graphs): + # node positions + pos = torch.stack([x[:, g], y[:, g]], dim=1) # shape [num_nodes, 2] + # edge attributes and weights + ei, ej = pos[edge_index[0]], pos[edge_index[1]] # [num_edges, 2] + edge_attr = torch.abs(ej - ei) # relative offsets + edge_weight = edge_attr.norm(p=2, dim=1, keepdim=True) # Euclidean distance + # node features (solution values) + node_features = u[:, g].unsqueeze(-1) # [num_nodes, 1] + # build PyG graph + graphs.append( + Data( + x=node_features, + edge_index=edge_index, + edge_weight=edge_weight, + edge_attr=edge_attr, + pos=pos, + ) + ) + + +# ## Training with PINA +# +# Everything is now ready! We can use **PINA** to train the model, following the workflow from previous tutorials. 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: +# +# - **Input**: the parameter tensor $\boldsymbol{\mu}$ describing each scenario. +# - **Output**: the corresponding graph structure (PyTorch Geometric `Data` object) that we aim to reconstruct. + +# In[5]: + + +problem = SupervisedProblem(params, graphs) + + +# Next, we build the **autoencoder network** and the **interpolation network**. +# +# - The **Graph Convolutional Autoencoder (GCA)** encodes the high-dimensional graph data into a compact latent space and reconstructs the graphs from this latent representation. +# - The **interpolation network** (or parametric map) learns to map a new parameter $\boldsymbol{\mu}^*$ directly into the latent space, enabling the model to predict solutions for unseen parameter instances without running the full encoder. + +# In[6]: + + +reduction_network = GraphConvolutionalAutoencoder( + hidden_channels=[1, 1], bottleneck=8, input_size=1352, ffn=200, act=nn.ELU +) +interpolation_network = FeedForward( + input_dimensions=2, + output_dimensions=8, + n_layers=2, + inner_size=200, + func=nn.Tanh, +) + + +# Finally, we will use the [`ReducedOrderModelSolver`](https://mathlab.github.io/PINA/_rst/solver/supervised_solver/reduced_order_model.html#pina.solver.supervised_solver.reduced_order_model.ReducedOrderModelSolver) to perform the training, as discussed earlier. +# +# This solver requires two components: +# - an **interpolation network**, which maps parameters $\boldsymbol{\mu}$ to the latent space, and +# - a **reduction network**, which in our case is the **autoencoder** that compresses and reconstructs the graph data. + +# In[7]: + + +# This loss handles both Data and Torch.Tensors +class CustomMSELoss(nn.MSELoss): + def forward(self, output, target): + if isinstance(output, Data): + output = output.x + if isinstance(target, Data): + target = target.x + return torch.nn.functional.mse_loss( + output, target, reduction=self.reduction + ) + + +# Define the solver +solver = ReducedOrderModelSolver( + problem=problem, + reduction_network=reduction_network, + interpolation_network=interpolation_network, + use_lt=False, + loss=CustomMSELoss(), + optimizer=TorchOptimizer(torch.optim.Adam, lr=0.001, weight_decay=1e-05), +) + + +# Training is performed as usual using the **`Trainer`** API. In this tutorial, we will use only **30% of the data** for training, and only $300$ epochs of training to illustrate the workflow. + +# In[ ]: + + +trainer = Trainer( + solver=solver, + accelerator="cpu", + max_epochs=300, + train_size=0.3, + val_size=0.7, + test_size=0.0, + shuffle=True, +) +trainer.train() + + +# Once the model is trained, we can test the reconstruction by following two steps: +# +# 1. **Interpolate**: Use the `interpolation_network` to map a new parameter $\boldsymbol{\mu}^*$ to the latent space. +# 2. **Decode**: Pass the interpolated latent vector through the autoencoder (`reduction_network`) to reconstruct the corresponding graph data. + +# In[9]: + + +# interpolate +z = interpolation_network(params) + +# decode +batch = Batch.from_data_list(graphs) +out = reduction_network.decode(z, decoding_graph=batch) +out, _ = to_dense_batch(out, batch.batch) +out = out.squeeze(-1).T.detach() + + +# Let's compute the total error, and plot a sample solution: + +# In[11]: + + +# compute error +l2_error = (torch.norm(out - u, dim=0) / torch.norm(u, dim=0)).mean() +print(f"L2 relative error {l2_error:.2%}") + +# plot solution +idx_to_plot = 42 +# Determine min and max values for color scaling +vmin = min(out[:, idx_to_plot].min(), u[:, idx_to_plot].min()) +vmax = max(out[:, idx_to_plot].max(), u[:, idx_to_plot].max()) +plt.figure(figsize=(16, 4)) +plt.subplot(1, 3, 1) +plt.tricontourf( + x[:, idx_to_plot], + y[:, idx_to_plot], + triang, + out[:, idx_to_plot], + 100, + cmap="jet", + vmin=vmin, + vmax=vmax, +) +plt.title("GCA-ROM") +plt.colorbar() +plt.subplot(1, 3, 2) +plt.title("True") +plt.tricontourf( + x[:, idx_to_plot], + y[:, idx_to_plot], + triang, + u[:, idx_to_plot], + 100, + cmap="jet", + vmin=vmin, + vmax=vmax, +) +plt.colorbar() +plt.subplot(1, 3, 3) +plt.title("Square Error") +plt.tricontourf( + x[:, idx_to_plot], + y[:, idx_to_plot], + triang, + (u - out).pow(2)[:, idx_to_plot], + 100, + cmap="jet", +) +plt.colorbar() +plt.ticklabel_format() +plt.show() + + +# Nice! We can see that the network is correctly learning the solution operator, and the workflow was very straightforward. +# +# You may notice that the network outputs are not as smooth as the actual solution. Don’t worry — training for longer (e.g., ~5000 epochs) will produce a smoother, more accurate reconstruction. +# +# ## What's Next? +# +# Congratulations on completing the introductory tutorial on **Graph Convolutional Reduced Order Modeling**! Now that you have a solid foundation, here are a few directions to explore: +# +# 1. **Experiment with Training Duration** — Try different training durations and adjust the network architecture to optimize performance. Explore different integral kernels and observe how the results vary. +# +# 2. **Explore Physical Constraints** — Incorporate physics-informed terms or constraints during training to improve model generalization and ensure physically consistent predictions. +# +# 3. **...and many more!** — The possibilities are vast! Continue experimenting with advanced configurations, solvers, and features in PINA. +# +# For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/). diff --git a/tutorials/tutorial9/tutorial.py b/tutorials/tutorial9/tutorial.py index 6797708e1..3906d87e7 100644 --- a/tutorials/tutorial9/tutorial.py +++ b/tutorials/tutorial9/tutorial.py @@ -2,14 +2,14 @@ # coding: utf-8 # # Tutorial: Applying Periodic Boundary Conditions in PINNs to solve the Helmholtz Problem -# +# # [![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) -# -# This tutorial demonstrates how to solve a one-dimensional Helmholtz equation with periodic boundary conditions (PBC) using Physics-Informed Neural Networks (PINNs). +# +# This tutorial demonstrates how to solve a one-dimensional Helmholtz equation with periodic boundary conditions (PBC) using Physics-Informed Neural Networks (PINNs). # We will use standard PINN 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). -# +# # Let's start with some useful imports: -# +# # In[1]: @@ -42,33 +42,33 @@ # ## Problem Definition -# +# # The one-dimensional Helmholtz problem is mathematically expressed as: -# +# # $$ # \begin{cases} # \frac{d^2}{dx^2}u(x) - \lambda u(x) - f(x) &= 0 \quad \text{for } x \in (0, 2) \\ # u^{(m)}(x = 0) - u^{(m)}(x = 2) &= 0 \quad \text{for } m \in \{0, 1, \dots\} # \end{cases} # $$ -# -# In this case, we seek a solution that is $C^{\infty}$ (infinitely differentiable) and periodic with period 2, over the infinite domain $x \in (-\infty, \infty)$. -# +# +# In this case, we seek a solution that is $C^{\infty}$ (infinitely differentiable) and periodic with period 2, over the infinite domain $x \in (-\infty, \infty)$. +# # A classical PINN approach would require enforcing periodic boundary conditions (PBC) for all derivatives—an infinite set of constraints—which is clearly infeasible. -# +# # To address this, we adopt a strategy known as *coordinate augmentation*. In this approach, we apply a coordinate transformation $v(x)$ such that the transformed inputs naturally satisfy the periodicity condition: -# +# # $$ # u^{(m)}(x = 0) - u^{(m)}(x = 2) = 0 \quad \text{for } m \in \{0, 1, \dots\} # $$ -# +# # For demonstration purposes, we choose the specific parameters: -# +# # - $\lambda = -10\pi^2$ # - $f(x) = -6\pi^2 \sin(3\pi x) \cos(\pi x)$ -# +# # These yield an analytical solution: -# +# # $$ # u(x) = \sin(\pi x) \cos(3\pi x) # $$ @@ -111,39 +111,39 @@ def solution(self, pts): # As usual, the Helmholtz problem is implemented in **PINA** as a class. The governing equations are defined as `conditions`, which must be satisfied within their respective domains. The `solution` represents the exact analytical solution, which will be used to evaluate the accuracy of the predicted solution. -# -# For selecting collocation points, we use Latin Hypercube Sampling (LHS), a common strategy for efficient space-filling in high-dimensional domains -# +# +# For selecting collocation points, we use Latin Hypercube Sampling (LHS), a common strategy for efficient space-filling in high-dimensional domains +# # ## Solving the Problem with a Periodic Network -# -# Any $\mathcal{C}^{\infty}$ periodic function $u : \mathbb{R} \rightarrow \mathbb{R}$ with period $L \in \mathbb{N}$ +# +# Any $\mathcal{C}^{\infty}$ periodic function $u : \mathbb{R} \rightarrow \mathbb{R}$ with period $L \in \mathbb{N}$ # can be constructed by composing an arbitrary smooth function $f : \mathbb{R}^n \rightarrow \mathbb{R}$ with a smooth, periodic mapping$v : \mathbb{R} \rightarrow \mathbb{R}^n$ of the same period $L$. That is, -# +# # $$ # u(x) = f(v(x)). # $$ -# -# This formulation is general and can be extended to arbitrary dimensions. +# +# This formulation is general and can be extended to arbitrary dimensions. # For more details, see [*A Method for Representing Periodic Functions and Enforcing Exactly Periodic Boundary Conditions with Deep Neural Networks*](https://arxiv.org/pdf/2007.07442). -# +# # In our specific case, we define the periodic embedding as: -# +# # $$ # v(x) = \left[1, \cos\left(\frac{2\pi}{L} x\right), \sin\left(\frac{2\pi}{L} x\right)\right], # $$ -# +# # which constitutes the coordinate augmentation. The function $f(\cdot)$ is approximated by a neural network $NN_{\theta}(\cdot)$, resulting in the approximate PINN solution: -# +# # $$ # u(x) \approx u_{\theta}(x) = NN_{\theta}(v(x)). # $$ -# -# In **PINA**, this is implemented using the `PeriodicBoundaryEmbedding` layer for $v(x)$, -# paired with any `pina.model` to define the neural network $NN_{\theta}$. -# +# +# In **PINA**, this is implemented using the `PeriodicBoundaryEmbedding` layer for $v(x)$, +# paired with any `pina.model` to define the neural network $NN_{\theta}$. +# # Let’s see how this is put into practice! -# -# +# +# # In[18]: @@ -160,11 +160,11 @@ def solution(self, pts): # As simple as that! -# -# In higher dimensions, you can specify different periods for each coordinate using a dictionary. -# For example, `periods = {'x': 2, 'y': 3, ...}` indicates a periodicity of 2 in the $x$ direction, +# +# In higher dimensions, you can specify different periods for each coordinate using a dictionary. +# For example, `periods = {'x': 2, 'y': 3, ...}` indicates a periodicity of 2 in the $x$ direction, # 3 in the $y$ direction, and so on. -# +# # We will now solve the problem using the usual `PINN` and `Trainer` classes. After training, we'll examine the losses using the `MetricTracker` callback from `pina.callback`. # In[ ]: @@ -240,15 +240,15 @@ def solution(self, pts): # It's clear that the network successfully captures the periodicity of the solution, with the error also exhibiting a periodic pattern. Naturally, training for a longer duration or using a more expressive neural network could further improve the results. # ## What's next? -# +# # Congratulations on completing the one-dimensional Helmholtz tutorial with **PINA**! Here are a few directions you can explore next: -# +# # 1. **Train longer or with different architectures**: Experiment with extended training or modify the network's depth and width to evaluate improvements in accuracy. -# +# # 2. **Apply `PeriodicBoundaryEmbedding` to time-dependent problems**: Explore more complex scenarios such as spatiotemporal PDEs (see the official documentation for examples). -# +# # 3. **Try extra feature training**: Integrate additional physical or domain-specific features to guide the learning process more effectively. -# +# # 4. **...and many more!**: Extend to higher dimensions, test on other PDEs, or even develop custom embeddings tailored to your problem. -# +# # For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/).