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.
- [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
evaluatemethod, decoupling the training loop from problem-specific logic and enabling fully modular, solver-agnostic conditions. -
[v0.3] – Code cleanup: core internals migrated to the
_srcpattern; 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.
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.
pip install "pina-mathlab"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:
devfor development purposestestfor running tests locallydocfor building documentation locallytutorialfor running tutorials
Solving a differential problem in PINA follows a clean four-step pipeline:
- Define the problem and constraints using the Problem API.
- Design your model using PyTorch, PyTorch Geometric, or import from the Model API.
- Select or build a Solver using the Solver API.
- 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.
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()Consider the following differential problem:
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()
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.
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}
}
![@github-actions[bot]](https://avatars.githubusercontent.com/in/15368?s=64&v=4){kind=small}
