Fix warnings in problem and loss

Author: FilippoOlivo

pina/loss/__init__.py

@@ -1,3 +1,7 @@
+"""
+Module for loss functions and weighting functions.
+"""
+
 __all__ = [
     "LossInterface",
     "LpLoss",

pina/loss/loss_interface.py

@@ -18,8 +18,8 @@ def __init__(self, reduction="mean"):
             will be applied, ``mean``: the sum of the output will be divided
             by the number of elements in the output, ``sum``: the output will
             be summed. Note: ``size_average`` and ``reduce`` are in the
-            process of being deprecated, and in the meantime, specifying either of
-            those two args will override ``reduction``. Default: ``mean``.
+            process of being deprecated, and in the meantime, specifying either
+            of those two args will override ``reduction``. Default: ``mean``.
         """
         super().__init__(reduction=reduction, size_average=None, reduce=None)
 
@@ -32,7 +32,6 @@ def forward(self, input, target):
         :return: Loss evaluation.
         :rtype: torch.Tensor
         """
-        pass
 
     def _reduction(self, loss):
         """Simple helper function to check reduction
@@ -42,8 +41,8 @@ def _reduction(self, loss):
             will be applied, ``mean``: the sum of the output will be divided
             by the number of elements in the output, ``sum``: the output will
             be summed. Note: ``size_average`` and ``reduce`` are in the
-            process of being deprecated, and in the meantime, specifying either of
-            those two args will override ``reduction``. Default: ``mean``.
+            process of being deprecated, and in the meantime, specifying either
+            of those two args will override ``reduction``. Default: ``mean``.
         :type reduction: str
         :param loss: Loss tensor for each element.
         :type loss: torch.Tensor

pina/loss/lp_loss.py

@@ -6,6 +6,8 @@
 from .loss_interface import LossInterface
 
 
+# Avoid pylint warning for torch.linalg.norm (it is callable)
+# pylint: disable=not-callable
 class LpLoss(LossInterface):
     r"""
     The Lp loss implementation class. Creates a criterion that measures
@@ -23,7 +25,8 @@ class LpLoss(LossInterface):
 
     .. math::
         \ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad
-        l_n = \frac{ [\sum_{i=1}^{D} | x_n^i - y_n^i|^p] }{[\sum_{i=1}^{D}|y_n^i|^p]},
+        l_n = \frac{ [\sum_{i=1}^{D} | x_n^i - y_n^i|^p] } \\
+            {[\sum_{i=1}^{D}|y_n^i|^p]},
 
     where :math:`N` is the batch size. If ``reduction`` is not ``none``
     (default ``mean``), then:
@@ -38,16 +41,19 @@ class LpLoss(LossInterface):
     :math:`x` and :math:`y` are tensors of arbitrary shapes with a total
     of :math:`n` elements each.
 
-    The sum operation still operates over all the elements, and divides by :math:`n`.
+    The sum operation still operates over all the elements, and divides by 
+    :math:`n`.
 
-    The division by :math:`n` can be avoided if one sets ``reduction`` to ``sum``.
+    The division by :math:`n` can be avoided if one sets ``reduction`` to 
+    ``sum``.
     """
 
     def __init__(self, p=2, reduction="mean", relative=False):
         """
         :param int p: Degree of Lp norm. It specifies the type of norm to
             be calculated. See `list of possible orders in torch linalg
-            <https://pytorch.org/docs/stable/generated/torch.linalg.norm.html#torch.linalg.norm>`_ to
+            `torch.linalg.norm <https://pytorch.org/docs/stable/generated/
+            torch.linalg.norm.html#torch.linalg.norm>`_
             for possible degrees. Default 2 (euclidean norm).
         :param str reduction: Specifies the reduction to apply to the output:
             ``none`` | ``mean`` | ``sum``. ``none``: no reduction

pina/loss/power_loss.py

@@ -17,13 +17,15 @@ class PowerLoss(LossInterface):
 
     .. math::
         \ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad
-        l_n = \frac{1}{D}\left[\sum_{i=1}^{D} \left| x_n^i - y_n^i \right|^p \right],
+        l_n = \frac{1}{D}\left[\sum_{i=1}^{D} 
+        \left| x_n^i - y_n^i \right|^p\right],
     
     If ``'relative'`` is set to true:
 
     .. math::
         \ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad
-        l_n = \frac{ \sum_{i=1}^{D} | x_n^i - y_n^i|^p }{\sum_{i=1}^{D}|y_n^i|^p},
+        l_n = \frac{ \sum_{i=1}^{D} | x_n^i - y_n^i|^p }
+        {\sum_{i=1}^{D}|y_n^i|^p},
 
     where :math:`N` is the batch size. If ``reduction`` is not ``none``
     (default ``mean``), then:
@@ -38,16 +40,19 @@ class PowerLoss(LossInterface):
     :math:`x` and :math:`y` are tensors of arbitrary shapes with a total
     of :math:`n` elements each.
 
-    The sum operation still operates over all the elements, and divides by :math:`n`.
+    The sum operation still operates over all the elements, and divides by 
+    :math:`n`.
 
-    The division by :math:`n` can be avoided if one sets ``reduction`` to ``sum``.
+    The division by :math:`n` can be avoided if one sets ``reduction`` to 
+    ``sum``.
     """
 
     def __init__(self, p=2, reduction="mean", relative=False):
         """
         :param int p: Degree of Lp norm. It specifies the type of norm to
             be calculated. See `list of possible orders in torch linalg
-            <https://pytorch.org/docs/stable/generated/torch.linalg.norm.html#torch.linalg.norm>`_ to
+            <https://pytorch.org/docs/stable/generated/
+            torch.linalg.norm.html#torch.linalg.norm>`_ to
             see the possible degrees. Default 2 (euclidean norm).
         :param str reduction: Specifies the reduction to apply to the output:
             ``none`` | ``mean`` | ``sum``. When ``none``: no reduction

pina/loss/weighting_interface.py

@@ -20,4 +20,3 @@ def aggregate(self, losses):
         :return: The losses aggregation. It should be a scalar Tensor.
         :rtype: torch.Tensor
         """
-        pass

pina/problem/zoo/__init__.py

@@ -1,3 +1,5 @@
+"""TODO"""
+
 __all__ = [
     "Poisson2DSquareProblem",
     "SupervisedProblem",

pina/problem/zoo/poisson_2d_square.py

@@ -1,12 +1,12 @@
 """Definition of the Poisson problem on a square domain."""
 
-from pina.problem import SpatialProblem
-from pina.operator import laplacian
-from pina import Condition
-from pina.domain import CartesianDomain
-from pina.equation.equation import Equation
-from pina.equation.equation_factory import FixedValue
 import torch
+from ..spatial_problem import SpatialProblem
+from ...operator import laplacian
+from ... import Condition
+from ...domain import CartesianDomain
+from ...equation.equation import Equation
+from ...equation.equation_factory import FixedValue
 
 
 def laplace_equation(input_, output_):
@@ -48,6 +48,8 @@ class Poisson2DSquareProblem(SpatialProblem):
     }
 
     def poisson_sol(self, pts):
+        """TODO"""
+
         return -(
             torch.sin(pts.extract(["x"]) * torch.pi)
             * torch.sin(pts.extract(["y"]) * torch.pi)

pina/problem/zoo/supervised_problem.py

@@ -1,14 +1,17 @@
-from pina.problem import AbstractProblem
-from pina import Condition
-from pina import Graph
+"""TODO"""
+
+from ..abstract_problem import AbstractProblem
+from ... import Condition
+from ... import Graph
 
 
 class SupervisedProblem(AbstractProblem):
     """
     A problem definition for supervised learning in PINA.
 
-    This class allows an easy and straightforward definition of a Supervised problem,
-    based on a single condition of type `InputTargetCondition`
+    This class allows an easy and straightforward definition of a
+    Supervised problem, based on a single condition of type
+    `InputTargetCondition`
 
     :Example:
         >>> import torch
@@ -17,7 +20,7 @@ class SupervisedProblem(AbstractProblem):
         >>> problem = SupervisedProblem(input_data, output_data)
     """
 
-    conditions = dict()
+    conditions = {}
     output_variables = None
 
     def __init__(self, input_, output_):