formatter

Author: dario-coscia

pina/solver/ensemble_solver/ensemble_pinn.py

@@ -150,7 +150,7 @@ def _residual_loss(self, samples, equation):
         Computes the physics loss for the physics-informed solver based on the
         provided samples and equation. This method should never be overridden
         by the user, if not intentionally,
-        since it is used internally to compute validation loss. It overrides the 
+        since it is used internally to compute validation loss. It overrides the
         :obj:`~pina.solver.physics_informed_solver.PINNInterface._residual_loss`
         method.
 

pina/solver/ensemble_solver/ensemble_solver_interface.py

@@ -45,6 +45,7 @@ class DeepEnsembleSolverInterface(MultiSolverInterface):
         processing systems, 30.
         DOI: `arXiv:1612.01474 <https://arxiv.org/abs/1612.01474>`_.
     """
+
     def __init__(
         self,
         problem,
@@ -99,19 +100,19 @@ def forward(self, x, ensemble_idx=None):
             return self.models[ensemble_idx].forward(x)
         # otherwise return the stacked output
         return torch.stack(
-                [self.forward(x, idx) for idx in range(self.num_ensembles)],
-                dim=self.ensemble_dim,
-            )
+            [self.forward(x, idx) for idx in range(self.num_ensembles)],
+            dim=self.ensemble_dim,
+        )
 
     def training_step(self, batch):
         """
         Training step for the solver, overridden for manual optimization.
         This method performs a forward pass, calculates the loss, and applies
-        manual backward propagation and optimization steps for each model in 
+        manual backward propagation and optimization steps for each model in
         the ensemble.
 
-        :param list[tuple[str, dict]] batch: A batch of training data. 
-            Each element is a tuple containing a condition name and a 
+        :param list[tuple[str, dict]] batch: A batch of training data.
+            Each element is a tuple containing a condition name and a
             dictionary of points.
         :return: The aggregated loss after the training step.
         :rtype: torch.Tensor

pina/solver/ensemble_solver/ensemble_supervised.py

@@ -57,6 +57,7 @@ class DeepEnsembleSupervisedSolver(
         processing systems, 30.
         DOI: `arXiv:1612.01474 <https://arxiv.org/abs/1612.01474>`_.
     """
+
     def __init__(
         self,
         problem,
@@ -102,8 +103,8 @@ def __init__(
 
     def loss_data(self, input, target):
         """
-        Compute the data loss for the EnsembleSupervisedSolver by evaluating 
-        the loss between the network's output and the true solution for each 
+        Compute the data loss for the EnsembleSupervisedSolver by evaluating
+        the loss between the network's output and the true solution for each
         model. This method should not be overridden, if not intentionally.
 
         :param input: The input to the neural network.

pina/solver/garom.py

@@ -51,8 +51,8 @@ def __init__(
             If ``None``, the :class:`torch.optim.Adam` optimizer is used.
             Default is ``None``.
         :param Optimizer optimizer_discriminator: The optimizer for the
-            discriminator. If ``None``, the :class:`torch.optim.Adam` optimizer is
-            used. Default is ``None``.
+            discriminator. If ``None``, the :class:`torch.optim.Adam` 
+            optimizer is used. Default is ``None``.
         :param Scheduler scheduler_generator: The learning rate scheduler for
             the generator.
             If ``None``, the :class:`torch.optim.lr_scheduler.ConstantLR`

pina/solver/physics_informed_solver/pinn_interface.py

@@ -53,7 +53,7 @@ def __init__(self, problem, loss=None, **kwargs):
         check_consistency(loss, (LossInterface, _Loss), subclass=False)
 
         # assign variables
-        self._loss = loss
+        self._loss_fn = loss
 
         # inverse problem handling
         if isinstance(self.problem, InverseProblem):
@@ -185,7 +185,7 @@ def _residual_loss(self, samples, equation):
         """
         Computes the physics loss for the physics-informed solver based on the
         provided samples and equation. This method should never be overridden
-        by the user, if not intentionally, 
+        by the user, if not intentionally,
         since it is used internally to compute validation loss.
 
 
@@ -215,7 +215,7 @@ def loss(self):
         :return: The loss function used for training.
         :rtype: torch.nn.Module
         """
-        return self._loss
+        return self._loss_fn
 
     @property
     def current_condition_name(self):

pina/solver/supervised_solver/supervised.py

@@ -68,7 +68,7 @@ def __init__(
             weighting=weighting,
             use_lt=use_lt,
         )
-
+    
     def loss_data(self, input, target):
         """
         Compute the data loss for the Supervised solver by evaluating the loss
@@ -82,4 +82,4 @@ def loss_data(self, input, target):
         :return: The supervised loss, averaged over the number of observations.
         :rtype: LabelTensor | torch.Tensor | Graph | Data
         """
-        return self._loss(self.forward(input), target)
+        return self.loss(self.forward(input), target)

pina/solver/supervised_solver/supervised_solver_interface.py

@@ -1,9 +1,9 @@
 """Module for the Supervised solver interface."""
 
-import torch
-
 from abc import abstractmethod
 
+import torch
+
 from torch.nn.modules.loss import _Loss
 from ..solver import SolverInterface
 from ...utils import check_consistency
@@ -16,8 +16,8 @@ class SupervisedSolverInterface(SolverInterface):
     Base class for Supervised solvers. This class implements a Supervised Solver
     , using a user specified ``model`` to solve a specific ``problem``.
 
-    The ``SupervisedSolverInterface`` class can be used to define 
-    Supervised solvers that work with one or multiple optimizers and/or models. 
+    The ``SupervisedSolverInterface`` class can be used to define
+    Supervised solvers that work with one or multiple optimizers and/or models.
     By default, it is compatible with problems defined by
     :class:`~pina.problem.abstract_problem.AbstractProblem`,
     and users can choose the problem type the solver is meant to address.
@@ -45,7 +45,7 @@ def __init__(self, loss=None, **kwargs):
         check_consistency(loss, (LossInterface, _Loss), subclass=False)
 
         # assign variables
-        self._loss = loss
+        self._loss_fn = loss
 
     def optimization_cycle(self, batch):
         """
@@ -87,4 +87,4 @@ def loss(self):
         :return: The loss function to be minimized.
         :rtype: torch.nn.Module
         """
-        return self._loss
+        return self._loss_fn

tests/test_solver/test_ensemble_pinn.py

@@ -27,7 +27,9 @@
 
 # define models
 models = [
-    FeedForward(len(problem.input_variables), len(problem.output_variables), n_layers=1)
+    FeedForward(
+        len(problem.input_variables), len(problem.output_variables), n_layers=1
+    )
     for _ in range(5)
 ]
 
@@ -84,6 +86,7 @@ def test_solver_validation(batch_size, compile):
             [isinstance(model, OptimizedModule) for model in solver.models]
         )
 
+
 @pytest.mark.parametrize("batch_size", [None, 1, 5, 20])
 @pytest.mark.parametrize("compile", [True, False])
 def test_solver_test(batch_size, compile):
@@ -104,6 +107,7 @@ def test_solver_test(batch_size, compile):
             [isinstance(model, OptimizedModule) for model in solver.models]
         )
 
+
 def test_train_load_restore():
     dir = "tests/test_solver/tmp"
     solver = DeepEnsemblePINN(models=models, problem=problem)

tests/test_solver/test_ensemble_supervised_solver.py

@@ -89,7 +89,9 @@ def forward(self, batch):
 
 
 def test_constructor():
-    solver=DeepEnsembleSupervisedSolver(problem=TensorProblem(), models=models)
+    solver = DeepEnsembleSupervisedSolver(
+        problem=TensorProblem(), models=models
+    )
     DeepEnsembleSupervisedSolver(problem=LabelTensorProblem(), models=models)
     assert DeepEnsembleSupervisedSolver.accepted_conditions_types == (
         InputTargetCondition
@@ -118,7 +120,9 @@ def test_solver_train(use_lt, batch_size, compile):
 
     trainer.train()
     if trainer.compile:
-        assert all([isinstance(model, OptimizedModule) for model in solver.models])
+        assert all(
+            [isinstance(model, OptimizedModule) for model in solver.models]
+        )
 
 
 @pytest.mark.parametrize("batch_size", [None, 1, 5, 20])