pina-mathlab 0.3.0

Physic Informed Neural networks for Advance modeling.

A Unified Framework for Scientific Machine Learning

PINA is an open-source Python library designed to simplify and accelerate the development of Scientific Machine Learning (SciML) solutions, including PINNs, Neural Operators, data-driven modeling, and more.

Built on top of

---

News & Announcements

• [v0.3] – New solvers: autoregressive solver for sequential prediction tasks and multi-model solver support. Internals redesigned around a mixin architecture — lightweight, single-responsibility mixins (preprocessing, forward, postprocessing) that can be freely composed, with residual computation and loss aggregation clearly separated.
• [v0.3] – Conditions refactoring: evaluation logic moved out of the solver and into the condition itself via a dedicated evaluate method, decoupling the training loop from problem-specific logic and enabling fully modular, solver-agnostic conditions.
• [v0.3] – Time-dependent conditions: added dedicated time series and graph time series conditions to support time-dependent problems and autoregressive formulations across sequential and graph-structured data.
• [v0.3] – Code cleanup: core internals migrated to the _src pattern; interfaces and base classes introduced across conditions, problems (AbstractProblem → BaseProblem), losses, and data module; equation zoo reorganized with Burgers added.
• [v0.3] – KAN support: Kolmogorov–Arnold Networks with fully vectorized spline basis and analytical derivatives.

Want the full history? See the Releases page.

---

What's PINA

PINA provides an intuitive framework for defining, experimenting with, and solving complex problems using Neural Networks, Physics-Informed Neural Networks (PINNs), Neural Operators, and more.

• Modular Architecture: Designed with modularity in mind and relying on powerful yet composable abstractions, PINA allows users to easily plug, replace, or extend components, making experimentation and customization straightforward.

• Scalable Performance: With native support for multi-device training, PINA handles large datasets efficiently, offering performance close to hand-crafted implementations with minimal overhead.

• Highly Flexible: Whether you're looking for full automation or granular control, PINA adapts to your workflow. High-level abstractions simplify model definition, while expert users can dive deep to fine-tune every aspect of the training and inference process.

---

Installation

      

Install a stable release

pip install "pina-mathlab"

Install from source

git clone https://github.com/mathLab/PINA
cd PINA
git checkout master
pip install .

Install with extra dependencies

To install additional packages required for development, tests, docs, or tutorials:

pip install "pina-mathlab[extras]"

Available extras:

• dev for development purposes
• test for running tests locally
• doc for building documentation locally
• tutorial for running tutorials

---

Getting started with PINA

           

Solving a differential problem in PINA follows a clean four-step pipeline:

1. Define the problem and constraints using the Problem API.
2. Design your model using PyTorch, PyTorch Geometric, or import from the Model API.
3. Select or build a Solver using the Solver API.
4. Train with the Trainer API, powered by PyTorch Lightning.

flowchart LR
    STEP1["<h2>Problem and Data</h2> Define the mathematical problem<br>Identify constraints or import data"]
    STEP2["<h2>Model Design</h2> Build a PyTorch module Choose or customize a model"]
    STEP3["<h2>Solver Selection</h2> Use available solvers or define your own strategy"]
    STEP4["<h2>Training</h2> Optimize the model with PyTorch Lightning"]

    STEP1 e1@--> STEP2
    STEP2 e2@--> STEP3
    STEP3 e3@--> STEP4
    e1@{ animate: true }
    e2@{ animate: true }
    e3@{ animate: true }

Want to dive deeper? Check out the official Tutorials.

---

PINA by Examples

      

Data-Driven Modeling Example

import torch
from pina import Trainer
from pina.model import FeedForward
from pina.solver import SupervisedSolver
from pina.problem.zoo import SupervisedProblem

input_tensor  = torch.rand((10, 1))
target_tensor = input_tensor.pow(3)

# Step 1. Define problem
problem = SupervisedProblem(input_tensor, target_tensor)

# Step 2. Define model
model = FeedForward(input_dimensions=1, output_dimensions=1, layers=[64, 64])

# Step 3. Define solver
solver = SupervisedSolver(problem, model, use_lt=False)

# Step 4. Train
trainer = Trainer(solver, max_epochs=1000, accelerator="gpu")
trainer.train()

---

Physics-Informed Example

Consider the following differential problem:

$$ \begin{cases} \frac{d}{dx}u(x) &= u(x) \quad x \in(0,1)\ u(x=0) &= 1 \end{cases} $$

In PINA, this can be implemented as:

from pina import Trainer, Condition
from pina.problem import SpatialProblem
from pina.operator import grad
from pina.solver import PINN
from pina.model import FeedForward
from pina.domain import CartesianDomain
from pina.equation import Equation, FixedValue

def ode_equation(input_, output_):
    u_x = grad(output_, input_, components=["u"], d=["x"])
    u = output_.extract(["u"])
    return u_x - u

class SimpleODE(SpatialProblem):
    output_variables = ["u"]
    spatial_domain = CartesianDomain({"x": [0, 1]})
    domains = {
        "x0": CartesianDomain({"x": 0.0}),
        "D": CartesianDomain({"x": [0, 1]}),
    }
    conditions = {
        "bound_cond": Condition(domain="x0", equation=FixedValue(1.0)),
        "phys_cond": Condition(domain="D", equation=Equation(ode_equation)),
    }

# Step 1. Define problem
problem = SimpleODE()
problem.discretise_domain(n=100, mode="grid", domains=["D", "x0"])

# Step 2. Define model
model = FeedForward(input_dimensions=1, output_dimensions=1, layers=[64, 64])

# Step 3. Define solver
solver = PINN(problem, model)

# Step 4. Train
trainer = Trainer(solver, max_epochs=1000, accelerator="gpu")
trainer.train()

---

Contributing & Community

      

We would love to develop PINA together with the community. A great place to start is the list of good-first-issue issues.

If you would like to contribute, please read the Contributing Guide.

Made with contrib.rocks.

---

Citation

      

If PINA has been significant in your research and you would like to acknowledge it, please cite:

Coscia, D., Ivagnes, A., Demo, N., & Rozza, G. (2023).
Physics-Informed Neural networks for Advanced modeling.
Journal of Open Source Software, 8(87), 5352.

Or in BibTeX format:

@article{coscia2023physics,
  title={Physics-Informed Neural networks for Advanced modeling},
  author={Coscia, Dario and Ivagnes, Anna and Demo, Nicola and Rozza, Gianluigi},
  journal={Journal of Open Source Software},
  volume={8},
  number={87},
  pages={5352},
  year={2023}
}