Select Solver

Select a Solver for a PINA Problem

[!IMPORTANT] Read RULES.md before using this skill — it applies to all skills.

Use this skill to pick the correct PINA solver — or design a custom one — based on your problem type, conditions, and training requirements.

PINA solvers are driven by conditions (data format) and model count (single vs ensemble). The condition types in your problem.conditions dictate which solver families are compatible; additional requirements (causality, gradient enhancement, adaptive weighting) narrow the choice further.

Step 1 — Understand the conditions

Start by identifying what kind of data your problem works with. Ask conversationally if the user hasn't already built their problem object:

• Time series? — Your conditions use n_windows and unroll_length. The data has a sequential structure and the model rolls out predictions step by step.
• Input → Target? — You have input points and known target values. This is standard supervised / regression data: Condition(input=..., target=...).
• PDE equations + domains? — Your conditions reference equations and domains/spatial points: Condition(domain=..., equation=...) or Condition(input=..., equation=...).
• Mixed? — Many physics-informed problems mix equation conditions (for the PDE interior) with target conditions (for boundary data or observations).

You can inspect an existing problem object directly:

for name, cond in problem.conditions.items():
    print(name, type(cond).__name__)

If the user hasn't defined conditions yet, ask if you can help setting up the problem.

Step 2 — Let the conditions drive the choice

Once the condition types are clear, map them to solver families. This is a decision tree, not a menu — work through it with the user.

Time series conditions

If every condition is (or includes) a TimeSeriesCondition:

→ AutoregressiveSingleModelSolver  (one model)
→ AutoregressiveEnsembleSolver     (multiple models, averaged)

No other solver family handles TimeSeriesCondition.

Key parameters:

• eps — noise injected during unrolling (regularisation)
• unroll_length — number of steps per forward pass

Input → Target conditions only

If all conditions are InputTargetCondition (no equations, no domains):

→ SupervisedSingleModelSolver  (one model)
→ SupervisedEnsembleSolver     (N models with deep ensemble)

The Ensemble variant trains N independent copies and averages their predictions at inference.

Equation conditions (physics-informed)

If conditions include InputEquationCondition or DomainEquationCondition, you're in the physics-informed family. Now ask two follow-up questions:

1. How many models: one or multiple?

Multiple models trains N independent copies and averages predictions.

2. Any special training requirement?

For the single-model physics-informed case, ask the user about these. Each maps to a distinct solver:

Self-adaptive and competitive are not single-model solvers — they manage multiple optimisers internally. SelfAdaptive trains a weight network alongside the model; Competitive trains a discriminator.

Ensemble + special requirements? The PhysicsInformedEnsembleSolver does not layer gradient/causal/self-adaptive on top. For those combinations, create a custom solver (Step 4).

Step 3 — Assemble the solver

Once the solver is chosen, the construction pattern is consistent:

from pina.solver import PhysicsInformedSingleModelSolver
# or any other solver

solver = PhysicsInformedSingleModelSolver(
    problem=problem,
    model=model,
    learning_rate=0.001,
    # optional:
    # loss=torch.nn.MSELoss(),
    # weighting=my_weighting,
    # scheduler=torch.optim.lr_scheduler.CosineAnnealingLR(...),
    # batch_size=32,
)

Step 4 — Creating a custom solver

When no built-in solver matches your requirements, PINA's architecture makes it straightforward to compose one. The key building blocks are mixins — reusable training_step and _compute_condition_loss overrides.