Source code for pina.equation.system_equation
""" Module for SystemEquation. """
import torch
from .equation import Equation
from ..utils import check_consistency
[docs]
class SystemEquation(Equation):
def __init__(self, list_equation, reduction=None):
"""
System of Equation class for specifing any system
of equations in PINA.
Each ``equation`` passed to a ``Condition`` object
must be an ``Equation`` or ``SystemEquation``.
A ``SystemEquation`` is specified by a list of
equations.
:param Callable equation: A ``torch`` callable equation to
evaluate the residual
:param str reduction: Specifies the reduction to apply to the output:
None | ``mean`` | ``sum`` | callable. None: no reduction
will be applied, ``mean``: the output sum will be divided
by the number of elements in the output, ``sum``: the output will
be summed. *callable* is a callable function to perform reduction,
no checks guaranteed. Default: None.
"""
check_consistency([list_equation], list)
# equations definition
self.equations = []
for _, equation in enumerate(list_equation):
self.equations.append(Equation(equation))
# possible reduction
if reduction == "mean":
self.reduction = torch.mean
elif reduction == "sum":
self.reduction = torch.sum
elif (reduction == None) or callable(reduction):
self.reduction = reduction
else:
raise NotImplementedError(
"Only mean and sum reductions implemented."
)
[docs]
def residual(self, input_, output_, params_=None):
"""
Residual computation for the equations of the system.
:param LabelTensor input_: Input points to evaluate the system of
equations.
:param LabelTensor output_: Output vectors given by a model (e.g,
a ``FeedForward`` model).
:param dict params_: Dictionary of parameters related to the inverse
problem (if any).
If the equation is not related to an ``InverseProblem``, the
parameters are initialized to ``None`` and the residual is
computed as ``equation(input_, output_)``.
Otherwise, the parameters are automatically initialized in the
ranges specified by the user.
:return: The residual evaluation of the specified system of equations,
aggregated by the ``reduction`` defined in the ``__init__``.
:rtype: LabelTensor
"""
residual = torch.hstack(
[
equation.residual(input_, output_, params_)
for equation in self.equations
]
)
if self.reduction is None:
return residual
return self.reduction(residual, dim=-1)