codacy

Author: dario-coscia

pina/solver/ensemble_solver/ensemble_pinn.py

@@ -127,7 +127,7 @@ def loss_data(self, input, target):
         :rtype: torch.Tensor
         """
         loss = sum(
-            self.loss(self.forward(input, idx), target)
+            self._loss_fn(self.forward(input, idx), target)
             for idx in range(self.num_ensembles)
         )
         return loss / self.num_ensembles
@@ -162,5 +162,5 @@ def _residual_loss(self, samples, equation):
         loss = 0
         for idx in range(self.num_ensembles):
             residuals = equation.residual(samples, self.forward(samples, idx))
-            loss = loss + self.loss(residuals, torch.zeros_like(residuals))
+            loss = loss + self._loss_fn(residuals, torch.zeros_like(residuals))
         return loss / self.num_ensembles

pina/solver/ensemble_solver/ensemble_supervised.py

@@ -115,7 +115,7 @@ def loss_data(self, input, target):
         :rtype: torch.Tensor
         """
         loss = sum(
-            self.loss(self.forward(input, idx), target)
+            self._loss_fn(self.forward(input, idx), target)
             for idx in range(self.num_ensembles)
         )
         return loss / self.num_ensembles

pina/solver/garom.py

@@ -51,7 +51,7 @@ 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` 
+            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.
@@ -88,7 +88,7 @@ def __init__(
         check_consistency(
             loss, (LossInterface, _Loss, torch.nn.Module), subclass=False
         )
-        self._loss = loss
+        self._loss_fn = loss
 
         # set automatic optimization for GANs
         self.automatic_optimization = False
@@ -157,10 +157,11 @@ def _train_generator(self, parameters, snapshots):
         generated_snapshots = self.sample(parameters)
 
         # generator loss
-        r_loss = self._loss(snapshots, generated_snapshots)
+        r_loss = self._loss_fn(snapshots, generated_snapshots)
         d_fake = self.discriminator([generated_snapshots, parameters])
         g_loss = (
-            self._loss(d_fake, generated_snapshots) + self.regularizer * r_loss
+            self._loss_fn(d_fake, generated_snapshots)
+            + self.regularizer * r_loss
         )
 
         # backward step
@@ -189,8 +190,8 @@ def _train_discriminator(self, parameters, snapshots):
         d_fake = self.discriminator([generated_snapshots, parameters])
 
         # evaluate loss
-        d_loss_real = self._loss(d_real, snapshots)
-        d_loss_fake = self._loss(d_fake, generated_snapshots.detach())
+        d_loss_real = self._loss_fn(d_real, snapshots)
+        d_loss_fake = self._loss_fn(d_fake, generated_snapshots.detach())
         d_loss = d_loss_real - self.k * d_loss_fake
 
         # backward step
@@ -270,7 +271,7 @@ def validation_step(self, batch):
                 points["target"],
             )
             snapshots_gen = self.generator(parameters)
-            condition_loss[condition_name] = self._loss(
+            condition_loss[condition_name] = self._loss_fn(
                 snapshots, snapshots_gen
             )
         loss = self.weighting.aggregate(condition_loss)
@@ -293,7 +294,7 @@ def test_step(self, batch):
                 points["target"],
             )
             snapshots_gen = self.generator(parameters)
-            condition_loss[condition_name] = self._loss(
+            condition_loss[condition_name] = self._loss_fn(
                 snapshots, snapshots_gen
             )
         loss = self.weighting.aggregate(condition_loss)

pina/solver/physics_informed_solver/causal_pinn.py

@@ -134,7 +134,7 @@ def loss_phys(self, samples, equation):
             chunk.labels = labels
             # classical PINN loss
             residual = self.compute_residual(samples=chunk, equation=equation)
-            loss_val = self.loss(
+            loss_val = self._loss_fn(
                 torch.zeros_like(residual, requires_grad=True), residual
             )
             time_loss.append(loss_val)

pina/solver/physics_informed_solver/competitive_pinn.py

@@ -156,7 +156,7 @@ def loss_phys(self, samples, equation):
         residual = residual * discriminator_bets
 
         # Compute competitive residual.
-        loss_val = self.loss(
+        loss_val = self._loss_fn(
             torch.zeros_like(residual, requires_grad=True),
             residual,
         )
@@ -175,7 +175,7 @@ def loss_data(self, input, target):
         :return: The supervised loss, averaged over the number of observations.
         :rtype: LabelTensor
         """
-        return self.loss(self.forward(input), target)
+        return self._loss_fn(self.forward(input), target)
 
     def configure_optimizers(self):
         """

pina/solver/physics_informed_solver/gradient_pinn.py

@@ -116,15 +116,15 @@ def loss_phys(self, samples, equation):
         """
         # classical PINN loss
         residual = self.compute_residual(samples=samples, equation=equation)
-        loss_value = self.loss(
+        loss_value = self._loss_fn(
             torch.zeros_like(residual, requires_grad=True), residual
         )
 
         # gradient PINN loss
         loss_value = loss_value.reshape(-1, 1)
         loss_value.labels = ["__loss"]
         loss_grad = grad(loss_value, samples, d=self.problem.spatial_variables)
-        g_loss_phys = self.loss(
+        g_loss_phys = self._loss_fn(
             torch.zeros_like(loss_grad, requires_grad=True), loss_grad
         )
         return loss_value + g_loss_phys

pina/solver/physics_informed_solver/pinn.py

@@ -95,7 +95,7 @@ def loss_data(self, input, target):
         :return: The supervised loss, averaged over the number of observations.
         :rtype: LabelTensor
         """
-        return self.loss(self.forward(input), target)
+        return self._loss_fn(self.forward(input), target)
 
     def loss_phys(self, samples, equation):
         """
@@ -108,7 +108,7 @@ def loss_phys(self, samples, equation):
         :rtype: LabelTensor
         """
         residuals = self.compute_residual(samples, equation)
-        return self.loss(residuals, torch.zeros_like(residuals))
+        return self._loss_fn(residuals, torch.zeros_like(residuals))
 
     def configure_optimizers(self):
         """

pina/solver/physics_informed_solver/pinn_interface.py

@@ -195,7 +195,7 @@ def _residual_loss(self, samples, equation):
         :rtype: torch.Tensor
         """
         residuals = self.compute_residual(samples, equation)
-        return self.loss(residuals, torch.zeros_like(residuals))
+        return self._loss_fn(residuals, torch.zeros_like(residuals))
 
     def _clamp_inverse_problem_params(self):
         """

pina/solver/physics_informed_solver/self_adaptive_pinn.py

@@ -299,7 +299,7 @@ def loss_data(self, input, target):
         :return: The supervised loss, averaged over the number of observations.
         :rtype: LabelTensor
         """
-        return self.loss(self.forward(input), target)
+        return self._loss_fn(self.forward(input), target)
 
     def _vect_to_scalar(self, loss_value):
         """

pina/solver/supervised_solver/reduced_order_model.py

@@ -181,10 +181,10 @@ def loss_data(self, input, target):
         # encoded representations loss
         encode_repr_inter_net = interpolation_network(input)
         encode_repr_reduction_network = reduction_network.encode(target)
-        loss_encode = self.loss(
+        loss_encode = self._loss_fn(
             encode_repr_inter_net, encode_repr_reduction_network
         )
         # reconstruction loss
         decode = reduction_network.decode(encode_repr_reduction_network)
-        loss_reconstruction = self.loss(decode, target)
+        loss_reconstruction = self._loss_fn(decode, target)
         return loss_encode + loss_reconstruction