class_docstr: This interface is used to construct a callable object of the ``L1Loss`` class.
  The L1Loss layer calculates the L1 Loss of ``input`` and ``label`` as follows.
   If `reduction` set to ``'none'``, the loss is:
  .. math::
      Out = \lvert input - label\rvert
  If `reduction` set to ``'mean'``, the loss is:
  .. math::
      Out = MEAN(\lvert input - label\rvert)
  If `reduction` set to ``'sum'``, the loss is:
  .. math::
      Out = SUM(\lvert input - label\rvert)
  
  Args:
      reduction (str, optional): Indicate the reduction to apply to the loss,
          the candicates are ``'none'`` | ``'mean'`` | ``'sum'``.
          If `reduction` is ``'none'``, the unreduced loss is returned;
          If `reduction` is ``'mean'``, the reduced mean loss is returned.
          If `reduction` is ``'sum'``, the reduced sum loss is returned.
          Default is ``'mean'``.
      ignore_index (int, optional): Specifies a target value that is ignored and does not contribute to the input gradient. Default: 255.
  Shape:
      input (Tensor): The input tensor. The shapes is [N, *], where N is batch size and `*` means any number of additional dimensions. It's data type should be float32, float64, int32, int64.
      label (Tensor): label. The shapes is [N, *], same shape as ``input`` . It's data type should be float32, float64, int32, int64.
      output (Tensor): The L1 Loss of ``input`` and ``label``.
          If `reduction` is ``'none'``, the shape of output loss is [N, *], the same as ``input`` .
          If `reduction` is ``'mean'`` or ``'sum'``, the shape of output loss is [1].
  Examples:
      .. code-block:: python
  
          import paddle
          import numpy as np
          input_data = np.array([[1.5, 0.8], [0.2, 1.3]]).astype("float32")
          label_data = np.array([[1.7, 1], [0.4, 0.5]]).astype("float32")
          input = paddle.to_tensor(input_data)
          label = paddle.to_tensor(label_data)
          l1_loss = paddle.nn.L1Loss()
          output = l1_loss(input, label)
          print(output.numpy())
          # [0.35]
          l1_loss = paddle.nn.L1Loss(reduction='sum')
          output = l1_loss(input, label)
          print(output.numpy())
          # [1.4]
          l1_loss = paddle.nn.L1Loss(reduction='none')
          output = l1_loss(input, label)
          print(output)
          # [[0.20000005 0.19999999]
          # [0.2        0.79999995]]
code: def forward(self, input, label):
      mask = label != self.ignore_index
      mask = paddle.cast(mask, "float32")
      label.stop_gradient = True
      mask.stop_gradient = True
  
      output = (
          paddle.nn.functional.l1_loss(
              input, label, "none", name=self.name
          )
          * mask
      )
  
      if self.reduction == "mean":
          return paddle.mean(output) / (paddle.mean(mask) + self.EPS)
      elif self.reduction == "none":
          return output
      elif self.reduction == "sum":
          return paddle.sum(output)
      else:
          raise ValueError(
              "The value of 'reduction' in L1Loss should be 'sum', 'mean' or 'none', but "
              "received %s, which is not allowed." % self.reduction
          )
  
file_path: PaddleSeg/paddleseg/models/losses/l1_loss.py
imports: import paddle
  from paddle import nn
  import paddle.nn.functional
  from paddleseg.cvlibs import manager
label_desc: Use image node_id 2 for calling the L1Loss obj's underlying member method code with example usage: obj.forward(input, label) and returns: unknown, output, paddle