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/physics_informed_solver/pinn_interface.py

@@ -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.
 
 

pina/solver/supervised_solver/supervised_solver_interface.py

@@ -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.

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])