mindspore 2.1.0__cp37-cp37m-win_amd64.whl → 2.2.11__cp37-cp37m-win_amd64.whl

mindspore/nn/loss/loss.py

@@ -43,14 +43,51 @@ class LossBase(Cell):
     to apply reduction to loss values.
 
     Args:
-        reduction (str): Type of reduction to be applied to loss. The optional values are ``"mean"`` , ``"sum"`` , and
-            ``"none"`` . Default: ``"mean"`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the (weighted) mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Raises:
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import ops, Tensor, nn
+        >>> import numpy as np
+        >>>
+        >>> class Net(nn.LossBase):
+        ...     def __init__(self, reduction='mean'):
+        ...         super(Net, self).__init__(reduction)
+        ...         self.abs = ops.Abs()
+        ...
+        ...     def construct(self, logits, labels):
+        ...         x = self.abs(logits - labels)
+        ...         output = self.get_loss(x)
+        ...         axis = self.get_axis(x)
+        ...         return output, axis
+        >>> net = Net()
+        >>> # Case 1: logits.shape = labels.shape = (3,)
+        >>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
+        >>> labels = Tensor(np.array([1, 2, 2]), mindspore.float32)
+        >>> output, axis = net(logits, labels)
+        >>> print(output)
+        0.33333334
+        >>> print(axis)
+        (0,)
+        >>> # Case 2: logits.shape = labels.shape = (3, 3)
+        >>> logits = Tensor(np.array([[1, 2, 3],[1, 2, 3],[1, 2, 3]]), mindspore.float32)
+        >>> labels = Tensor(np.array([[1, 2, 2],[1, 2, 3],[1, 2, 3]]), mindspore.float32)
+        >>> output, axis = net(logits, labels)
+        >>> print(output)
+        0.11111111
+        >>> print(axis)
+        (0, 1)
     """
 
     def __init__(self, reduction='mean'):
@@ -79,34 +116,6 @@ class LossBase(Cell):
 
         Args:
             x (Tensor): Tensor of any shape.
-
-        Examples:
-            >>> import mindspore
-            >>> from mindspore import ops, Tensor, nn
-            >>> import numpy as np
-            >>>
-            >>> class Net(nn.LossBase):
-            ...     def __init__(self, reduction='mean'):
-            ...         super(Net, self).__init__(reduction)
-            ...         self.abs = ops.Abs()
-            ...
-            ...     def construct(self, logits, labels):
-            ...         x = self.abs(logits - labels)
-            ...         axis = self.get_axis(x)
-            ...         return axis
-            >>> net = Net()
-            >>> # Case 1: logits.shape = labels.shape = (3,)
-            >>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
-            >>> labels = Tensor(np.array([1, 2, 3]), mindspore.float32)
-            >>> output = net(logits, labels)
-            >>> print(output)
-            (0,)
-            >>> # Case 2: logits.shape = labels.shape = (3, 3)
-            >>> logits = Tensor(np.array([[1, 2, 3],[1, 2, 3],[1, 2, 3]]), mindspore.float32)
-            >>> labels = Tensor(np.array([[1, 2, 3],[1, 2, 3],[1, 2, 3]]), mindspore.float32)
-            >>> output = net(logits, labels)
-            >>> print(output)
-            (0, 1)
         """
         shape = F.shape(x)
         length = F.tuple_len(shape)
@@ -126,34 +135,6 @@ class LossBase(Cell):
 
         Returns:
             Return the weighted loss.
-
-        Examples:
-            >>> import mindspore
-            >>> from mindspore import ops, Tensor, nn
-            >>> import numpy as np
-            >>>
-            >>> class Net(nn.LossBase):
-            ...     def __init__(self, reduction='mean'):
-            ...         super(Net, self).__init__(reduction)
-            ...         self.abs = ops.Abs()
-            ...
-            ...     def construct(self, logits, labels):
-            ...         x = self.abs(logits - labels)
-            ...         output = self.get_loss(x)
-            ...         return output
-            >>> net = Net()
-            >>> # Case 1: logits.shape = labels.shape = (3,)
-            >>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
-            >>> labels = Tensor(np.array([1, 2, 2]), mindspore.float32)
-            >>> output = net(logits, labels)
-            >>> print(output)
-            0.33333334
-            >>> # Case 2: logits.shape = labels.shape = (3, 3)
-            >>> logits = Tensor(np.array([[1, 2, 3],[1, 2, 3],[1, 2, 3]]), mindspore.float32)
-            >>> labels = Tensor(np.array([[1, 2, 2],[1, 2, 3],[1, 2, 3]]), mindspore.float32)
-            >>> output = net(logits, labels)
-            >>> print(output)
-            0.11111111
         """
         input_dtype = x.dtype
         x = self.cast(x, mstype.float32)
@@ -203,7 +184,7 @@ class L1Loss(LossBase):
     .. math::
         \ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad \text{with } l_n = \left| x_n - y_n \right|,
 
-    where :math:`N` is the batch size. If `reduction` is not 'none', then:
+    where :math:`N` is the batch size. If `reduction` is not ``'none'``, then:
 
     .. math::
         \ell(x, y) =
@@ -213,9 +194,12 @@ class L1Loss(LossBase):
         \end{cases}
 
     Args:
-        reduction (str): Type of reduction to be applied to loss. The optional values are ``"mean"`` , ``"sum"`` , and
-            ``"none"`` . Default: ``"mean"`` . If `reduction` is ``"mean"`` or ``"sum"`` , then output a scalar Tensor,
-            if `reduction` is ``"none"`` , the shape of the output Tensor is the broadcasted shape.
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **logits** (Tensor) - Predicted value, Tensor of any dimension.
@@ -227,7 +211,7 @@ class L1Loss(LossBase):
         Tensor, data type is float.
 
     Raises:
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
         ValueError: If `logits` and `labels` have different shapes and cannot be broadcasted to each other.
 
     Supported Platforms:
@@ -273,7 +257,7 @@ class MSELoss(LossBase):
     .. math::
         \ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad \text{with} \quad l_n = (x_n - y_n)^2.
 
-    where :math:`N` is the batch size. If `reduction` is not 'none', then:
+    where :math:`N` is the batch size. If `reduction` is not ``'none'``, then:
 
     .. math::
         \ell(x, y) =
@@ -283,8 +267,12 @@ class MSELoss(LossBase):
         \end{cases}
 
     Args:
-        reduction (str): Type of reduction to be applied to loss. The optional values are ``"mean"`` , ``"sum"`` , and
-            ``"none"`` . Default: ``'mean'`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **logits** (Tensor) - The predicted value of the input. Tensor of any dimension.
@@ -293,11 +281,11 @@ class MSELoss(LossBase):
           and they should be broadcasted to each other.
 
     Outputs:
-        Tensor, loss of type float, the shape is zero if `reduction` is 'mean' or 'sum',
+        Tensor, loss of type float, the shape is zero if `reduction` is ``'mean'`` or ``'sum'`` .,
         while the shape of output is the broadcasted shape if `reduction` is 'none'.
 
     Raises:
-        ValueError: If `reduction` is not one of 'none', 'mean' or 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'`` or ``'sum'``.
         ValueError: If `logits` and `labels` have different shapes and cannot be broadcasted.
 
     Supported Platforms:
@@ -412,7 +400,7 @@ class MAELoss(LossBase):
     .. math::
         \ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad \text{with } l_n = \left| x_n - y_n \right|,
 
-    where :math:`N` is the batch size. If `reduction` is not 'none', then:
+    where :math:`N` is the batch size. If `reduction` is not ``'none'``, then:
 
     .. math::
         \ell(x, y) =
@@ -422,8 +410,12 @@ class MAELoss(LossBase):
         \end{cases}
 
     Args:
-        reduction (str): Type of reduction to be applied to loss. The optional values are ``"mean"`` , ``"sum"`` , and
-                         ``"none"`` . Default: ``"mean"`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **logits** (Tensor) - Tensor of shape :math:`(M, *)` where :math:`*` means, any number of
@@ -433,11 +425,11 @@ class MAELoss(LossBase):
           and they should be broadcasted to each other.
 
     Outputs:
-        Tensor, weighted loss float tensor, the shape is zero if `reduction` is 'mean' or 'sum',
+        Tensor, weighted loss float tensor, the shape is zero if `reduction` is ``'mean'`` or ``'sum'`` .,
         while the shape of output is the broadcasted shape if `reduction` is 'none'.
 
     Raises:
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -487,9 +479,12 @@ class MarginRankingLoss(LossBase):
 
     Args:
         margin (float, optional): Specify the adjustment factor of the operation. Default: ``0.0`` .
-        reduction (str, optional): Specifies which reduction to be applied to the output. It must be one of
-            ``"none"`` , ``"mean"`` , and ``"sum"`` , meaning no reduction, reduce mean and sum on output,
-            respectively. Default: ``"mean"`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **input1** (Tensor) - Tensor of shape :math:`(N, *)` where :math:`*` means, any number
@@ -499,7 +494,7 @@ class MarginRankingLoss(LossBase):
           :math:`(x_1, x_2, x_3, ..., x_R)`, then the shape of `target` must be :math:`(x_1, x_2, x_3, ..., x_R)`.
 
     Outputs:
-        Tensor or Scalar. if `reduction` is "none", its shape is the same as `labels`.
+        Tensor or Scalar. if `reduction` is ``"none"``, its shape is the same as `labels`.
         Otherwise, a scalar value will be returned.
 
     Raises:
@@ -509,7 +504,7 @@ class MarginRankingLoss(LossBase):
         TypeError: If the types of `input1` and `target` are inconsistent.
         ValueError: If the shape of `input1` and `input2` are inconsistent.
         ValueError: If the shape of `input1` and `target` are inconsistent.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'`` , ``'sum'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -582,8 +577,12 @@ class SmoothL1Loss(LossBase):
     Args:
         beta (float): The loss function calculates the threshold of the transformation between L1Loss and L2Loss.
             Default: ``1.0`` .
-        reduction (str): Type of reduction to be applied to loss. The optional values are ``"mean"`` , ``"sum"`` , and
-                         ``"none"`` . Default: ``"none"`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'none'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **logits** (Tensor) - Predictive value. Tensor of any dimension. Data type must be one of float16,
@@ -591,12 +590,12 @@ class SmoothL1Loss(LossBase):
         - **labels** (Tensor) - Ground truth data, same shape and dtype as the `logits`.
 
     Outputs:
-        Tensor, if `reduction` is 'none', then output is a tensor with the same shape as `logits`.
+        Tensor, if `reduction` is ``'none'``, then output is a tensor with the same shape as `logits`.
         Otherwise the shape of output tensor is :math:`()`.
 
     Raises:
         TypeError: If `beta` is not a float.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
         TypeError: If `logits` or `labels` are not Tensor.
         TypeError: If dtype of `logits` or `labels` is neither float16 not float32.
         TypeError: If dtype of `logits` is not the same as `labels`.
@@ -638,27 +637,31 @@ class SoftMarginLoss(LossBase):
     (containing 1 or -1).
 
     .. math::
-        \text{loss}(x, y) = \sum_i \frac{\log(1 + \exp(-y[i]*x[i]))}{\text{x.nelement}()}
+        \text{loss}(x, y) = \sum_i \frac{\log(1 + \exp(-y[i]*x[i]))}{x.nelement()}
 
     :math:`x.nelement()` represents the number of element of `x` .
 
     Args:
-        reduction (str): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` , ``'sum'`` .
-            Default: ``"mean"`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **logits** (Tensor) - Predict data. Data type must be float16 or float32.
         - **labels** (Tensor) - Ground truth data, with the same type and shape as `logits`.
 
     Outputs:
-        Tensor or Scalar, if `reduction` is "none", its shape is the same as `logits`.
+        Tensor or Scalar, if `reduction` is ``"none"``, its shape is the same as `logits`.
         Otherwise, a scalar value will be returned.
 
     Raises:
         TypeError: If `logits` or `labels` is not a Tensor.
         TypeError: If dtype of `logits` or `labels` is neither float16 nor float32.
         ValueError: If shape of `logits` is not the same as `labels`.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU``
@@ -710,9 +713,13 @@ class SoftmaxCrossEntropyWithLogits(LossBase):
         of entry is a valid one.
 
     Args:
-        sparse (bool): Specifies whether labels use sparse format or not. Default: ``False`` .
-        reduction (str): Type of reduction to be applied to loss. The optional values are ``"mean"`` , ``"sum"`` , and
-            ``"none"`` . If ``"none"`` , do not perform reduction. Default: ``"none"`` .
+        sparse (bool, optional): Specifies whether labels use sparse format or not. Default: ``False`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'none'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **logits** (Tensor) - Tensor of shape :math:`(N, C)` . Data type must be float16 or float32.
@@ -726,7 +733,7 @@ class SoftmaxCrossEntropyWithLogits(LossBase):
         TypeError: If `sparse` is not a bool.
         TypeError: If `sparse` is True and dtype of `labels` is neither int32 not int64.
         TypeError: If `sparse` is False and dtype of `labels` is neither float16 not float32.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -984,8 +991,12 @@ class SampledSoftmaxLoss(LossBase):
         remove_accidental_hits (bool): Whether to remove "accidental hits"
             where a sampled class equals to one of the labels classes. Default: ``True`` .
         seed (int): Random seed for candidate sampling. Default: 0
-        reduction (str): Type of reduction to be applied to loss. The optional values are ``"mean"`` , ``"sum"`` , and
-            ``"none"`` . If ``"none"`` , do not perform reduction. Default: ``"none"`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'none'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **weights** (Tensor) - Tensor of shape :math:`(C, dim)`.
@@ -994,13 +1005,13 @@ class SampledSoftmaxLoss(LossBase):
         - **logits** (Tensor) - Tensor of shape :math:`(N, dim)`. The forward activations of the input network.
 
     Outputs:
-        Tensor or Scalar, if `reduction` is 'none', then output is a tensor with shape :math:`(N,)`.
+        Tensor or Scalar, if `reduction` is ``'none'``, then output is a tensor with shape :math:`(N,)`.
         Otherwise, the output is a scalar.
 
     Raises:
         TypeError: If `sampled_values` is not a list or tuple.
         TypeError: If dtype of `labels` is neither int32 not int64.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
         ValueError: If `num_sampled` or `num_true` is greater than `num_classes`.
         ValueError: If length of `sampled_values` is not equal to 3.
 
@@ -1228,8 +1239,13 @@ class TripletMarginWithDistanceLoss(LossBase):
         swap (bool): The distance swap is described in detail in the paper
             `Learning shallow convolutional feature descriptors with triplet losses` by
             V. Balntas, E. Riba et al. Default: ``False`` .
-        reduction (str): Apply specific reduction method to the output:
-            ``'none'`` , ``'mean'`` , ``'sum'`` . Default: ``'mean'`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
+
         margin (float): Make a margin between the positive pair and the negative pair. Default: ``1.0`` .
 
     Inputs:
@@ -1241,7 +1257,7 @@ class TripletMarginWithDistanceLoss(LossBase):
           with the same type and shape as `x`.
 
     Outputs:
-        Union[Tensor, Scalar], if `reduction` is 'none', its shape is :math:`(N)`.
+        Union[Tensor, Scalar], if `reduction` is ``'none'``, its shape is :math:`(N)`.
         Otherwise, a scalar value will be returned.
 
     Raises:
@@ -1250,7 +1266,7 @@ class TripletMarginWithDistanceLoss(LossBase):
         ValueError: If dimensions of input `x`, `positive` and `negative` are less than or equal to 1 at the same time.
         ValueError: If length of shape of `margin` is not 0.
         ValueError: If shape of `x`, `positive` and `negative` cannot broadcast.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1333,15 +1349,19 @@ class PoissonNLLLoss(LossBase):
         full (bool, optional): Whether include the Stirling approximation term in the loss calculation.
             Default: ``False`` .
         eps (float, optional): Lower bound of `input` when calculating logarithms. Default: ``1e-08`` .
-        reduction (str, optional): Apply specific reduction method to the output:
-            ``'none'`` , ``'mean'`` , ``'sum'`` . Default: ``'mean'`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **input** (Tensor) - The input Tensor. The shape can be any number of dimensions.
         - **target** (Tensor) - The label Tensor which has the same shape as `input`.
 
     Outputs:
-        Tensor or Scalar, if `reduction` is 'none', then output is a tensor and has the same shape as `input`.
+        Tensor or Scalar, if `reduction` is ``'none'``, then output is a tensor and has the same shape as `input`.
         Otherwise it is a scalar.
 
     Raises:
@@ -1411,25 +1431,28 @@ class MultiLabelSoftMarginLoss(LossBase):
         \sum_{j = 1}^{C}\left(y_{ij}\log\frac{1}{1 + e^{- x_{ij}}} + \left( 1 - y_{ij}
         \right)\log\frac{e^{-x_{ij}}}{1 + e^{-x_{ij}}} \right)
 
-    where :math:`x{ij}` represents the predicted score of sample :math:`i` for class :math:`j`. :math:`y{ij}`
+    where :math:`x_{ij}` represents the predicted score of sample :math:`i` for class :math:`j`. :math:`y_{ij}`
     represents the binary label of sample :math:`i` for class :math:`j`, where sample :math:`i` belongs to
-    class :math:`j` if :math:`y{ij}=1` , and sample :math:`i` does not belong to class :math:`j` if :math:`y{ij}=0`.
+    class :math:`j` if :math:`y_{ij}=1` , and sample :math:`i` does not belong to class :math:`j` if :math:`y_{ij}=0`.
     For a multi-label classification task, each sample may have multiple labels with a value of 1 in the binary
     label :math:`y`. `weight` will multiply to the loss of each class if given.
 
     Args:
         weight (Union[Tensor, int, float]): The manual rescaling weight given to each class. Default: ``None`` .
-        reduction (str): Specifies which reduction to be applied to the output. It must be one of
-            ``'none'`` , ``'mean'`` , and ``'sum'`` , meaning no reduction, reduce mean and sum on output,
-            respectively. Default: ``'mean'`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the weighted mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
-        - **x** (Tensor) - A tensor of shape (N, C), where N is batch size and C is number
+        - **x** (Tensor) - A tensor of shape :math:`(N, C)`, where N is batch size and C is number
           of classes.
         - **target** (Tensor) - The label target Tensor which has the same shape as `x`.
 
     Outputs:
-        Tensor, the data type is the same as x, if the reduction is 'none', its shape is (N), otherwise it is zero.
+        Tensor, the data type is the same as x, if the reduction is ``'none'``, its shape is (N), otherwise it is zero.
 
     Raises:
         ValueError: If the rank of `x` or `target` is not 2.
@@ -1481,8 +1504,8 @@ class MultiMarginLoss(LossBase):
             ``'sum'`` . Default: ``'mean'`` .
 
             - ``'none'``: no reduction 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.
+            - ``'mean'``: compute and return the weighted mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
         weight (Tensor, optional): The rescaling weight to each class with shape :math:`(C,)`. Data type only
             support float32, float16 or float64. Default: ``None`` , all classes are weighted equally.
@@ -1494,7 +1517,7 @@ class MultiMarginLoss(LossBase):
           value of target should be non-negative, less than C. `target` is :math:`y` in the above formula.
 
     Outputs:
-        Tensor, When `reduction` is 'none', the shape is :math:`(N,)`.
+        Tensor, When `reduction` is ``'none'``, the shape is :math:`(N,)`.
         Otherwise, it is a scalar. Has the same data type with `x`.
 
     Raises:
@@ -1504,7 +1527,7 @@ class MultiMarginLoss(LossBase):
         TypeError: If dtype of `x` is not float16, float or float64.
         TypeError: If dtype of `weight` and `x` is not the same.
         ValueError: If 'p' is not 1 or 2.
-        ValueError: If 'reduction' is not one of {'none','sum','mean'}.
+        ValueError: If 'reduction' is not one of { ``'none'`` , ``'sum'`` , ``'mean'`` }.
         ValueError: If shape[0] of `x` is not equal to shape[0] of `target`.
         ValueError: If shape[1] of `x` is not equal to shape[0] of `weight`.
         ValueError: IF rank of `weight` is not 1.
@@ -1529,7 +1552,6 @@ class MultiMarginLoss(LossBase):
         """Initialize MultiMarginLoss."""
         super(MultiMarginLoss, self).__init__()
         self.multi_margin_loss = MultiMarginLossOp(p=p, margin=margin, reduction=reduction)
-        self.generate_ones = ops.Fill()
         self.weight = weight
 
     def construct(self, x, target, weight=None):
@@ -1541,7 +1563,7 @@ class MultiMarginLoss(LossBase):
         if not weight_one:
             _check_is_tensor('weight', weight, self.cls_name)
         else:
-            weight = self.generate_ones(x.dtype, x.astype('float32')[0].shape, 1)
+            weight = F.fill(x.dtype, x.astype('float32')[0].shape, 1)
         loss = self.multi_margin_loss(x, target, weight)
         return loss
 
@@ -1575,8 +1597,12 @@ class BCELoss(LossBase):
     Args:
         weight (Tensor, optional): A rescaling weight applied to the loss of each batch element.
             And it must have the same shape and data type as `inputs`. Default: ``None`` .
-        reduction (str): Specifies the reduction to be applied to the output.
-            Its value must be one of ``'none'`` , ``'mean'`` , ``'sum'`` . Default: ``'mean'`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the weighted mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **logits** (Tensor) - The input tensor with shape :math:`(N, *)` where :math:`*` means, any number
@@ -1585,12 +1611,12 @@ class BCELoss(LossBase):
           of additional dimensions. The same shape and data type as `logits`.
 
     Outputs:
-        Tensor, has the same dtype as `logits`. if `reduction` is 'none', then it has the same shape as `logits`.
+        Tensor, has the same dtype as `logits`. if `reduction` is ``'none'``, then it has the same shape as `logits`.
         Otherwise, it is a scalar Tensor.
 
     Raises:
         TypeError: If dtype of `logits`, `labels` or `weight` (if given) is neither float16 not float32.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
         ValueError: If shape of `logits` is not the same as `labels` or `weight` (if given).
 
     Supported Platforms:
@@ -1650,9 +1676,12 @@ class CosineEmbeddingLoss(LossBase):
 
     Args:
         margin (float): Should be in [-1.0, 1.0]. Default: ``0.0`` .
-        reduction (str): Specifies which reduction to be applied to the output. It must be one of
-            ``"none"`` , ``"mean"`` , and ``"sum"`` , meaning no reduction,
-            reduce mean and sum on output, respectively. Default: ``"mean"`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **logits_x1** (Tensor) - Tensor of shape :math:`(N, *)` where :math:`*` means, any number
@@ -1662,12 +1691,12 @@ class CosineEmbeddingLoss(LossBase):
           :math:`(x_1, x_2, x_3, ..., x_R)`, then the shape of `labels` must be :math:`(x_1, x_3, x_4, ..., x_R)`.
 
     Outputs:
-        Tensor or Scalar, if `reduction` is "none", its shape is the same as `labels`.
+        Tensor or Scalar, if `reduction` is ``"none"``, its shape is the same as `labels`.
         Otherwise, a scalar value will be returned.
 
     Raises:
         TypeError: If `margin` is not a float.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
         ValueError: If `margin` is not in range [-1, 1].
 
     Supported Platforms:
@@ -1744,7 +1773,11 @@ class MultilabelMarginLoss(LossBase):
 
     Args:
         reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
-            ``'sum'`` . Default: ``"mean"`` .
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **x** (Tensor) - Predict data. Tensor of shape :math:`(C)` or :math:`(N, C)`, where :math:`N`
@@ -1753,7 +1786,7 @@ class MultilabelMarginLoss(LossBase):
           label targets padded by -1.
 
     Outputs:
-        - **y** (Union[Tensor, Scalar]) - The loss of MultilabelMarginLoss. If `reduction` is "none", its shape
+        - **y** (Union[Tensor, Scalar]) - The loss of MultilabelMarginLoss. If `reduction` is ``"none"``, its shape
           is :math:`(N)`. Otherwise, a scalar value will be returned.
 
     Raises:
@@ -1762,7 +1795,7 @@ class MultilabelMarginLoss(LossBase):
         TypeError: If dtype of `target` is not int32.
         ValueError: If length of shape of `x` is neither 1 nor 2.
         ValueError: If shape of `x` is not the same as `target`.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU``
@@ -1811,8 +1844,13 @@ class BCEWithLogitsLoss(LossBase):
         \end{cases}
 
     Args:
-        reduction (str): Type of reduction to be applied to loss. The optional values are ``'mean'`` , ``'sum'`` , and
-            ``'none'`` . If ``'none'`` , do not perform reduction. Default: ``'mean'`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the weighted mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
+
         weight (Tensor, optional): A rescaling weight applied to the loss of each batch element.
             If not None, it can be broadcast to a tensor with shape of `logits`,
             data type must be float16 or float32. Default: ``None`` .
@@ -1827,7 +1865,7 @@ class BCEWithLogitsLoss(LossBase):
           of additional dimensions. The same shape and data type as `logits`.
 
     Outputs:
-        Tensor or Scalar, if `reduction` is 'none', its shape is the same as `logits`.
+        Tensor or Scalar, if `reduction` is ``'none'``, its shape is the same as `logits`.
         Otherwise, a scalar value will be returned.
 
     Raises:
@@ -1837,7 +1875,7 @@ class BCEWithLogitsLoss(LossBase):
         TypeError: If data type of `weight` or `pos_weight` is neither float16 nor float32.
         TypeError: If data type of `reduction` is not string.
         ValueError: If `weight` or `pos_weight` can not be broadcast to a tensor with shape of `logits`.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
     Supported Platforms:
         ``Ascend``  ``GPU``  ``CPU``
@@ -1858,28 +1896,17 @@ class BCEWithLogitsLoss(LossBase):
         """Initialize BCEWithLogitsLoss."""
         super(BCEWithLogitsLoss, self).__init__()
         self.reduction = reduction
-        self.bce_with_logits_loss = P.BCEWithLogitsLoss(reduction=reduction)
         if isinstance(weight, Parameter):
             raise TypeError(f"For '{self.cls_name}', the 'weight' can not be a Parameter.")
         if isinstance(pos_weight, Parameter):
             raise TypeError(f"For '{self.cls_name}', the 'pos_weight' can not be a Parameter.")
         self.weight = weight
         self.pos_weight = pos_weight
-        self.ones = P.OnesLike()
 
     def construct(self, logits, labels):
         _check_is_tensor('logits', logits, self.cls_name)
         _check_is_tensor('labels', labels, self.cls_name)
-        ones_input = self.ones(logits)
-        if self.weight is not None:
-            weight = self.weight
-        else:
-            weight = ones_input
-        if self.pos_weight is not None:
-            pos_weight = self.pos_weight
-        else:
-            pos_weight = ones_input
-        loss = self.bce_with_logits_loss(logits, labels, weight, pos_weight)
+        loss = ops.binary_cross_entropy_with_logits(logits, labels, self.weight, self.pos_weight, self.reduction)
         return loss
 
 
@@ -1932,9 +1959,12 @@ class FocalLoss(LossBase):
         gamma (float): Gamma is used to adjust the steepness of weight curve in focal loss. Default: ``2.0`` .
         weight (Union[Tensor, None]): A rescaling weight applied to the loss of each batch element. The dimension of
                                       weight should be 1. If None, no weight is applied. Default: ``None`` .
-        reduction (str): Type of reduction to be applied to loss. The optional values
-                         are ``"mean"`` , ``"sum"`` , and ``"none"``.
-                         If "none", do not perform reduction. Default: ``"mean"`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the weighted mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **logits** (Tensor) - Tensor of shape should be :math:`(N, C)` or :math:`(N, C, H)` or :math:`(N, C, H, W)`.
@@ -1948,7 +1978,7 @@ class FocalLoss(LossBase):
           range [-:math:`C`, :math:`C`). Where :math:`C` is the number of classes in logits.
 
     Outputs:
-        Tensor or Scalar, if `reduction` is "none", its shape is the same as `logits`.
+        Tensor or Scalar, if `reduction` is ``"none"``, its shape is the same as `logits`.
         Otherwise, a scalar value will be returned.
 
     Raises:
@@ -1956,7 +1986,7 @@ class FocalLoss(LossBase):
         TypeError: If `weight` is not a Tensor.
         ValueError: If `labels` dim is different from `logits`.
         ValueError: If `labels` channel is not 1 and `labels` shape is different from `logits`.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
     Supported Platforms:
         ``Ascend``
@@ -2050,7 +2080,7 @@ class HuberLoss(LossBase):
             delta * (|x_n - y_n| - 0.5 * delta), & \text{otherwise. }
         \end{cases}
 
-    where :math:`N` is the batch size. If `reduction` is not "none", then:
+    where :math:`N` is the batch size. If `reduction` is not ``"none"``, then:
 
     .. math::
         \ell(x, y) =
@@ -2060,9 +2090,13 @@ class HuberLoss(LossBase):
         \end{cases}
 
     Args:
-        reduction (str): Type of reduction to be applied to loss. The optional values are ``"mean"`` , ``"sum"`` , and
-            ``"none"`` . If `reduction` is ``"mean"`` or ``"sum"`` , then output a scalar Tensor, if `reduction` is
-            ``"none"`` , the shape of the output Tensor is the broadcasted shape. Default: ``"mean"``.
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
+
         delta (Union[int, float]): The threshold to change between two type of loss.
             The value must be positive. Default: ``1.0`` .
 
@@ -2073,7 +2107,7 @@ class HuberLoss(LossBase):
           and they should be broadcasted to each other.
 
     Outputs:
-        Tensor or Scalar, if `reduction` is "none", return a Tensor with same shape and dtype as `logits`.
+        Tensor or Scalar, if `reduction` is ``"none"``, return a Tensor with same shape and dtype as `logits`.
         Otherwise, a scalar value will be returned.
 
     Raises:
@@ -2081,7 +2115,7 @@ class HuberLoss(LossBase):
         TypeError: If data type of `logits` or `labels` are not the same.
         TypeError: If dtype of `delta` is neither float nor int.
         ValueError: If `delta` is less than or equal to 0.
-        ValueError: If `reduction` is not one of "none", "mean", "sum".
+        ValueError: If `reduction` is not one of ``"none"``, ``"mean"``, ``"sum"``.
         ValueError: If `logits` and `labels` have different shapes and cannot be broadcasted to each other.
 
     Supported Platforms:
@@ -2150,7 +2184,12 @@ class TripletMarginLoss(LossBase):
         swap (bool, optional): The distance swap change the negative distance to the distance between positive
             sample and negative sample. Default: ``False`` .
         reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
-            ``'sum'`` . Default: ``"mean"`` .
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
+
         margin (Union[Tensor, float]) - Make a margin between the positive pair and the negative pair.
             Default: ``1.0`` .
 
@@ -2165,7 +2204,7 @@ class TripletMarginLoss(LossBase):
           Default: ``1.0`` .
 
     Outputs:
-        Tensor. If `reduction` is "none", its shape is :math:`(N)`. Otherwise, a scalar value will be returned.
+        Tensor. If `reduction` is ``"none"``, its shape is :math:`(N)`. Otherwise, a scalar value will be returned.
 
     Raises:
         TypeError: If `x` or `positive` or 'negative' is not a Tensor.
@@ -2177,7 +2216,7 @@ class TripletMarginLoss(LossBase):
         ValueError: If the dimension of input `x` or `positive` or `negative` is bigger than or equal to 8.
         ValueError: If length of shape of `margin` is not 0.
         ValueError: If shape of `x`, `positive` and `negative` cannot broadcast.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
     Supported Platforms:
         ``GPU``
@@ -2239,7 +2278,7 @@ class NLLLoss(LossBase):
     :math:`N` is the batch size, :math:`c` belonging to :math:`[0, C-1]` is class index,
     where :math:`C` is the number of classes.
 
-    If `reduction` is not 'none' (default 'mean'), then
+    If `reduction` is not ``'none'`` (default 'mean'), then
 
     .. math::
 
@@ -2253,8 +2292,12 @@ class NLLLoss(LossBase):
             The data type only supports float32 or float16. Default: ``None`` .
         ignore_index (int): Specifies a target value that is ignored (typically for padding value)
             and does not contribute to the gradient. Default: ``-100`` .
-        reduction (str):  Apply specific reduction method to the output: ``'none'`` , ``'mean'`` , or ``'sum'`` .
-            Default: ``'mean'`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the weighted mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **logits** (Tensor) - Tensor of shape :math:`(N, C)`
@@ -2270,7 +2313,7 @@ class NLLLoss(LossBase):
         TypeError: If `weight` is not a Tensor.
         TypeError: If `ignore_index` is not an int.
         TypeError: If the data type of `weight` is not float16 or float32.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
         TypeError: If `logits` is not a Tensor.
         TypeError: If `labels` is not a Tensor.
 
@@ -2356,7 +2399,7 @@ class CrossEntropyLoss(LossBase):
       where :math:`x` is the inputs, :math:`t` is the target, :math:`w` is the weight,
       N is the batch size, :math:`c` belonging to [0, C-1] is class index, where :math:`C` is the number of classes.
 
-      If reduction is not 'none' (default 'mean'), then
+      If reduction is not ``'none'`` (default 'mean'), then
 
       .. math::
 
@@ -2378,7 +2421,7 @@ class CrossEntropyLoss(LossBase):
       where :math:`x` is the inputs, :math:`t` is the target, :math:`w` is the weight,
       N is the batch size, :math:`c` belonging to [0, C-1] is class index, where :math:`C` is the number of classes.
 
-      If reduction is not 'none' (default 'mean'), then
+      If reduction is not ``'none'`` (default 'mean'), then
 
       .. math::
 
@@ -2394,8 +2437,13 @@ class CrossEntropyLoss(LossBase):
             The data type only supports float32 or float16. Default: ``None`` .
         ignore_index (int): Specifies a target value that is ignored (typically for padding value)
             and does not contribute to the gradient. Default: ``-100`` .
-        reduction (str):  Apply specific reduction method to the output: ``'none'`` , ``'mean'`` , or ``'sum'`` .
-            Default: ``'mean'`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the weighted mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
+
         label_smoothing (float): Label smoothing values, a regularization tool used to prevent the model
             from overfitting when calculating Loss. The value range is [0.0, 1.0]. Default value: ``0.0`` .
 
@@ -2414,7 +2462,7 @@ class CrossEntropyLoss(LossBase):
         TypeError: If `weight` is not a Tensor.
         TypeError: If `ignore_index` is not an int.
         TypeError: If the data type of `weight` is not float16 or float32.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
         TypeError: If `label_smoothing` is not a float.
         TypeError: If `logits` is not a Tensor.
         TypeError: If `labels` is not a Tensor.
@@ -2562,8 +2610,13 @@ class CTCLoss(LossBase):
 
     Args:
         blank (int, optional): The blank label. Default: ``0`` .
-        reduction (str, optional): Implements the reduction method to the output with
-            ``'none'`` , ``'mean'`` , or ``'sum'`` . Default: ``'mean'`` .
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
+
         zero_infinity (bool, optional): If loss is infinite, this parameter determines whether to set that loss
             and its correlated gradient to zero. Default: ``False`` .
 
@@ -2583,7 +2636,7 @@ class CTCLoss(LossBase):
         TypeError: If `zero_infinity` is not a bool, `reduction` is not string.
         TypeError: If the dtype of `log_probs` is not float or double.
         TypeError: If the dtype of `targets`, `input_lengths` or `target_lengths` is not int32 or int64.
-        ValueError: If `reduction` is not "none", "mean" or "sum".
+        ValueError: If `reduction` is not ``"none"``, ``"mean"`` or ``"sum"``.
         ValueError: If the value of `blank` is not in range [0, C). C is number of classes of `log_probs` .
         ValueError: If the shape of `log_probs` is :math:`(T, C)`, the dimension of `targets` is not 1 or 2.
         ValueError: If the shape of `log_probs` is :math:`(T, C)`, the first dimension of 2-D `target` is not 1.
@@ -2669,9 +2722,13 @@ class GaussianNLLLoss(LossBase):
         full (bool, optional): Whether include the constant term in the loss calculation. When :math:`full=True`,
             the constant term `const.` will be :math:`0.5 * log(2\pi)`. Default: ``False`` .
         eps (float, optional): Used to improve the stability of log function. Default: ``1e-6`` .
-        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` , or
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
             ``'sum'`` . Default: ``'mean'`` .
 
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
+
     Inputs:
         - **logits** (Tensor) - Tensor of shape :math:`(N, *)` or :math:`(*)` where :math:`*` means any number of
           additional dimensions.
@@ -2690,7 +2747,7 @@ class GaussianNLLLoss(LossBase):
         TypeError: If `full` is not a bool.
         TypeError: If `eps` is not a float.
         ValueError: If `eps` is not a float within (0, inf).
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2758,9 +2815,13 @@ class HingeEmbeddingLoss(LossBase):
     Args:
         margin (float, int): Threshold defined by Hinge Embedding Loss :math:`margin`.
             Represented as :math:`\Delta` in the formula. Default: ``1.0`` .
-        reduction (str): Specify the computing method to be applied to the outputs: ``'none'`` , ``'mean'`` , or
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
             ``'sum'`` . Default: ``'mean'`` .
 
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
+
     Inputs:
         - **logits** (Tensor) - The predicted value, expressed as :math:`x` in the equation.
           Tensor of shape :math:`(*)` where :math:`*` means any number of dimensions.
@@ -2775,7 +2836,7 @@ class HingeEmbeddingLoss(LossBase):
         TypeError: If `labels` is not a Tensor.
         TypeError: If `margin` is not a float or int.
         ValueError: If `labels` does not have the same shape as `logits` or they could not broadcast to each other.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``