PINA

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.2] – Agentic PINA: Added AI agents that guide users through the PINA pipeline, with dedicated skills for problem setup, model and solver selection, and training configuration.


  [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/pina-org/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:

Define the problem and constraints using the
[Problem API](https://mathlab.github.io/PINA/_rst/_code.html#problems).


Design your model using PyTorch, PyTorch Geometric, or import from the
[Model API](https://mathlab.github.io/PINA/_rst/_code.html#models).


Select or build a Solver using the
[Solver API](https://mathlab.github.io/PINA/_rst/_code.html#solvers).


Train with the
[Trainer API](https://mathlab.github.io/PINA/_rst/trainer.html),
powered by PyTorch Lightning.

flowchart LR
    STEP1["
Problem and Data
 Define the mathematical problem  
Identify constraints or import data"]
    STEP2["
Model Design
 Build a PyTorch module Choose or customize a model"]
    STEP3["
Solver Selection
 Use available solvers or define your own strategy"]
    STEP4["
Training
 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.problem.zoo import SupervisedProblem
from pina.solver import SupervisedSingleModelSolver

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 = SupervisedSingleModelSolver(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.operator import grad
from pina.model import FeedForward
from pina.equation import Equation
from pina import Trainer, Condition
from pina.domain import CartesianDomain
from pina.problem import SpatialProblem
from pina.equation.zoo import FixedValue
from pina.solver import PhysicsInformedSingleModelSolver

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 = PhysicsInformedSingleModelSolver(problem, model)

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

AI-Assisted Development

This repository includes AI agent skills (guides for opencode, Claude Code, Cursor) that walk you through the full PINA workflow — from problem definition to trained solver — through natural conversation.

Skills are located at .opencode/skills/<name>/SKILL.md and cover:

pina-workflow — Orchestrates a complete session (entry point) create-problem — Setting up physics-driven or data-driven problems define-domains — Creating and discretising domains define-equations — Writing PDEs/ODEs and using the equation zoo condition-setup — Binding equations to domains select-model, select-solver, select-trainer — Architecture and training

Just open the project in a compatible agent and start describing your problem — the agent will guide you step by step.

Or type /pina-agentic (in opencode or Claude Code) to launch an interactive session that walks you through the full workflow end-to-end.

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} }