mindspore 2.0.0a0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/nn/loss/loss.py

@@ -14,6 +14,7 @@
 # ============================================================================
 """loss"""
 from __future__ import absolute_import, division
+import math
 
 import mindspore
 import mindspore.common.dtype as mstype
@@ -25,15 +26,12 @@ from mindspore.ops import operations as P
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.ops.operations.nn_ops import MultiMarginLoss as MultiMarginLossOp
 from mindspore.ops.operations.nn_ops import MultilabelMarginLoss as MultilabelMarginLossOp
-from mindspore.ops.operations.nn_ops import TripletMarginLoss as TripletMarginLossOp
-from mindspore.ops.operations.nn_ops import CTCLossV2
 from mindspore.ops import functional as F
 from mindspore import nn
-from mindspore.ops.primitive import constexpr
+from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.nn.cell import Cell
 from mindspore.nn.layer.activation import get_activation
-from mindspore._checkparam import Validator as validator
-from mindspore._checkparam import Rel
+from mindspore import _checkparam as validator
 from mindspore import context
 
 
@@ -248,13 +246,10 @@ class L1Loss(LossBase):
     def __init__(self, reduction='mean'):
         """Initialize L1Loss."""
         super(L1Loss, self).__init__(reduction)
-        self.abs = P.Abs()
+        self.reduction = reduction
 
     def construct(self, logits, labels):
-        _check_is_tensor('logits', logits, self.cls_name)
-        _check_is_tensor('labels', labels, self.cls_name)
-        x = self.abs(logits - labels)
-        return self.get_loss(x)
+        return F.l1_loss(logits, labels, self.reduction)
 
 
 class MSELoss(LossBase):
@@ -464,23 +459,23 @@ class MarginRankingLoss(LossBase):
     r"""
     MarginRankingLoss creates a criterion that measures the loss.
 
-    Given two tensors :math:`x1`, :math:`x2` and a Tensor label :math:`y` with values 1 or -1,
+    Given two tensors :math:`input1`, :math:`input2` and a Tensor label :math:`target` with values 1 or -1,
     the operation is as follows:
 
     .. math::
-        \text{loss}(x1, x2, y) = \max(0, -y * (x1 - x2) + \text{margin})
+        \text{loss}(input1, input2, target) = \max(0, -target * (input1 - input2) + \text{margin})
 
     Args:
-        margin (float): Specify the adjustment factor of the operation. 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".
+        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".
 
     Inputs:
         - **input1** (Tensor) - Tensor of shape :math:`(N, *)` where :math:`*` means, any number
           of additional dimensions.
         - **input2** (Tensor) - Tensor of shape :math:`(N, *)`, same shape and dtype as `input1`.
         - **target** (Tensor) - Contains value 1 or -1. Suppose the shape of `input1` is
-          :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)`.
+          :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`.
@@ -670,11 +665,11 @@ class SoftmaxCrossEntropyWithLogits(LossBase):
     Measures the distribution error between the probabilities of the input (computed with softmax function) and the
     labels where the classes are mutually exclusive (only one class is positive) using cross entropy loss.
 
-    Typical input into this function is unnormalized scores denoted as x whose shape is (N, C),
+    Typical input into this function is unnormalized scores denoted as x whose shape is :math:`(N, C)` ,
     and the corresponding targets.
 
     Typically, the input to this function is the fractional value of each category and the corresponding target value,
-    and the input format is (N, C).
+    and the input format is :math:`(N, C)` .
 
     For each instance :math:`x_i`, i ranges from 0 to N-1, the loss is given as:
 
@@ -695,8 +690,8 @@ class SoftmaxCrossEntropyWithLogits(LossBase):
             If "none", do not perform reduction. Default: "none".
 
     Inputs:
-        - **logits** (Tensor) - Tensor of shape (N, C). Data type must be float16 or float32.
-        - **labels** (Tensor) - Tensor of shape (N, ). If `sparse` is True, The type of
+        - **logits** (Tensor) - Tensor of shape :math:`(N, C)` . Data type must be float16 or float32.
+        - **labels** (Tensor) - Tensor of shape :math:`(N, )` . If `sparse` is True, The type of
           `labels` is int32 or int64. Otherwise, the type of `labels` is the same as the type of `logits`.
 
     Outputs:
@@ -779,9 +774,8 @@ class DiceLoss(LossBase):
                         Default: 1e-5.
 
     Inputs:
-        - **logits** (Tensor) - Tensor of shape :math:`(N, *)` where :math:`*` means, any number of
-          additional dimensions. The data type must be float16 or float32.
-        - **labels** (Tensor) - Tensor of shape :math:`(N, *)`, same shape as the `logits`.
+        - **logits** (Tensor) - Input predicted value. The data type must be float16 or float32.
+        - **labels** (Tensor) - Input target value. Same shape as the `logits`.
           The data type must be float16 or float32.
 
     Outputs:
@@ -827,13 +821,13 @@ class DiceLoss(LossBase):
         return dice_loss
 
 
-@constexpr
+@_primexpr
 def _check_shape(logits_shape, label_shape, prim_name=None):
     """Internal function, used to check whether the shape of logits and labels meets the requirements."""
     validator.check('logits_shape', logits_shape, 'label_shape', label_shape, prim_name=prim_name)
 
 
-@constexpr
+@_primexpr
 def _check_ndim_multi(logits_dim, label_dim, prim_name=None):
     """Internal function, used to check whether the dimension of logits and label meets the requirements."""
     msg_prefix = f'For \'{prim_name}\', the' if prim_name else "The"
@@ -843,7 +837,7 @@ def _check_ndim_multi(logits_dim, label_dim, prim_name=None):
         raise ValueError(f"{msg_prefix} 'labels' dimension must be greater than 1, but got {label_dim}.")
 
 
-@constexpr
+@_primexpr
 def _check_weights(weight_shape, label_shape, prim_name=None):
     """Internal function, used to check whether the reduced shape meets the requirements."""
     msg_prefix = f'For \'{prim_name}\', the' if prim_name else "The"
@@ -1070,7 +1064,7 @@ class SampledSoftmaxLoss(LossBase):
     def _softmax_cross_entropy(self, logits, targets):
         stable_exp_logits = self.exp(logits - self.reduce_max_true(logits, 1))
         pred = stable_exp_logits / self.reduce_sum_true(stable_exp_logits, 1)
-        return -self.reduce_sum(targets * self.log(pred + 1.0e-20), 1)
+        return -1 * self.reduce_sum(targets * self.log(pred + 1.0e-20), 1)
 
     def _compute_sampled_logits(self, weights,
                                 biases,
@@ -1165,6 +1159,156 @@ class SampledSoftmaxLoss(LossBase):
         return out_logits, out_labels
 
 
+class PoissonNLLLoss(LossBase):
+    r"""
+    Poisson negative log likelihood loss.
+
+    The loss is:
+
+    .. math::
+        \mathcal{L}_{D} = \sum_{i = 0}^{|D|}\left( x_{i} - y_{i}\ln x_{i} + \ln{y_{i}!} \right)
+
+    where :math:`\mathcal{L}_{D}` is the loss, :math:`y_{i}` is the `target`,
+    :math:`x_{i}` is the `input`.
+
+    If `log_input` is True, use :math:`e^{x_{i}} - y_{i} x_{i}` instead of :math:`x_{i} - y_{i}\ln x_{i}`.
+    When calculating logarithms, the lower bound of `input` is set to `eps` to avoid numerical errors.
+
+    If `full` is False, the last term :math:`\ln{y_{i}!}` will be omitted,
+    otherwise the last term will be approximated using Stirling formula:
+
+    .. math::
+        n! \approx \sqrt{2\pi n}\left( \frac{n}{e} \right)^{n}
+
+    Note:
+        Calculating the logarithm of a negative number or the exponent of a large positive number under Ascend
+        will have a different range of return values and results different from those under GPU and CPU.
+
+    Args:
+        log_input (bool, optional): Whether use log input. Default: True.
+        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'.
+
+    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`.
+        Otherwise it is a scalar.
+
+    Raises:
+        TypeError: If `reduction` is not a str.
+        TypeError: If neither `input` nor `target` is a tensor.
+        TypeError: If dtype of `input` or `target` is not currently supported.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor([[0.3, 0.7], [0.5, 0.5]])
+        >>> target = Tensor([[1.0, 2.0], [3.0, 4.0]])
+        >>> loss = nn.PoissonNLLLoss()
+        >>> output = loss(x, target)
+        >>> print(output.asnumpy())
+        0.3652635
+    """
+
+    def __init__(self, log_input=True, full=False, eps=1e-08, reduction="mean"):
+        """Initialize PoissonNLLLoss."""
+        super(PoissonNLLLoss, self).__init__(reduction=reduction)
+        self.log_input = log_input
+        self.full = full
+        self.eps = eps
+        self.maximum = P.Maximum()
+        self.cast = P.Cast()
+
+    def construct(self, input, target):
+        _check_is_tensor('input', input, self.cls_name)
+        _check_is_tensor('target', target, self.cls_name)
+        if input.ndim == 0 or target.ndim == 0:
+            raise ValueError(
+                "For 'PoissonNLLLoss', the inputs must be non-scalar, but got shapes: "
+                f"input: {input.shape}, target: {target.shape}"
+            )
+        target = self.cast(target, input.dtype)
+        if self.log_input:
+            loss = input.exp() - target * input
+        else:
+            loss = input - target * ((input + self.eps).log())
+        if self.full:
+            target = self.maximum(target, self.eps)
+            stirling_term = (target > 1) * ((target + 0.5) * target.log() - target + get_half_ln_2_pi())
+            loss += F.masked_fill(stirling_term, target <= 1, 0)
+        out = self.get_loss(loss)
+        return out
+
+
+@constexpr
+def get_half_ln_2_pi():
+    return 0.5 * math.log(2 * math.pi)
+
+
+class MultiLabelSoftMarginLoss(LossBase):
+    r"""
+    Calculates the MultiLabelSoftMarginLoss.
+    The multi-label soft margin loss is a commonly used loss function in multi-label classification tasks
+    where an input sample can belong to multiple classes.
+    Given an input :math:`x` and binary labels :math:`y` of size :math:`(N,C)`, where :math:`N` denotes
+    the number of samples and :math:`C` denotes the number of classes.
+
+    .. math::
+        \mathcal{loss\left( x , y \right)} = - \frac{1}{N}\frac{1}{C}\sum_{i = 1}^{N}
+        \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}`
+    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`.
+    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'.
+
+    Inputs:
+        - **x** (Tensor) - A tensor of shape (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.
+
+    Raises:
+        ValueError: If the rank of `x` or `target` is not 2.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor([[0.3, 0.6, 0.6], [0.9, 0.4, 0.2]])
+        >>> target = Tensor([[0.0, 0.0, 1.0], [0.0, 0.0, 1.0]])
+        >>> loss = nn.MultiLabelSoftMarginLoss(reduction='mean')
+        >>> out = loss(x, target)
+        >>> print(out.asnumpy())
+        0.84693956
+    """
+
+    def __init__(self, weight=None, reduction="mean"):
+        """Initialize MultiLabelSoftMarginLoss."""
+        super(MultiLabelSoftMarginLoss, self).__init__(reduction)
+        self.weight = weight
+        self.reduction = reduction
+
+    def construct(self, x, target):
+        return F.multilabel_soft_margin_loss(x, target, self.weight, self.reduction)
+
+
 class MultiMarginLoss(LossBase):
     r"""
     Creates a criterion that optimizes a multi-class classification hinge
@@ -1176,25 +1320,28 @@ class MultiMarginLoss(LossBase):
     output :math:`y` is:
 
     .. math::
-        \text{loss}(x, y) = \frac{\sum_i \max(0, w[y] * (\text{margin} - x[y] + x[i]))^p)}{\text{x.size}(0)}
+        \text{loss}(x, y) = \frac{\sum_i \max(0, w[y] * (\text{margin} - x[y] + x[i]))^p}{\text{x.size}(0)}
 
     where :math:`x \in \left\{0, \; \cdots , \; \text{x.size}(0) - 1\right\}`
     and :math:`i \neq y`.
 
-    Optionally, you can give non-equal weighting on the classes by passing
-    a 1D input `weight` tensor w into the constructor.
-
     Args:
-        p (int): Optional. The norm degree for pairwise distance. Should be 1 or 2. Default: 1.
-        margin (float): Optional. A parameter to change pairwise distance. Default: 1.0.
-        reduction (str): Apply specific reduction method to the output: 'none', 'mean', 'sum'. Default: "mean".
+        p (int, optional): The norm degree for pairwise distance. Should be 1 or 2. Default: 1.
+        margin (float, optional): A parameter to change pairwise distance. Default: 1.0.
+        reduction (str, optional): Apply specific reduction method to the output: 'none', 'mean', '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.
+
+        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.
 
     Inputs:
         - **x** (Tensor) - Input x, with shape :math:`(N, C)`. Data type only support float32, float16 or float64.
         - **target** (Tensor) - Ground truth labels, with shape :math:`(N,)`. Data type only support int64. The
           value of target should be non-negative, less than C.
-        - **weight** (Tensor, optional) - The rescaling weight to each class with shape :math:`(C,)`. Data type only
-          support float32, float16 or float64. Default: None.
 
     Outputs:
         Tensor, When `reduction` is 'none', the shape is :math:`(N,)`.
@@ -1214,7 +1361,7 @@ class MultiMarginLoss(LossBase):
         ValueError: If rank of `x` is not 2 or rank of 'target' is not 1.
 
     Supported Platforms:
-        ``Ascend``  ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.ones(shape=[3, 3]), mindspore.float32)
@@ -1225,20 +1372,23 @@ class MultiMarginLoss(LossBase):
         0.6666667
     """
 
-    def __init__(self, p=1, margin=1.0, reduction='mean'):
+    def __init__(self, p=1, margin=1.0, reduction='mean', weight=None):
         """Initialize MultiMarginLoss."""
         super(MultiMarginLoss, self).__init__()
         self.multi_margin_loss = MultiMarginLossOp(p=p, margin=margin, reduction=reduction)
-        self.ones = P.Ones()
+        self.generate_ones = ops.Fill()
+        self.weight = weight
 
     def construct(self, x, target, weight=None):
         _check_is_tensor('x', x, self.cls_name)
         _check_is_tensor('target', target, self.cls_name)
+        if self.weight is not None:
+            weight = self.weight
         weight_one = weight is None
         if not weight_one:
             _check_is_tensor('weight', weight, self.cls_name)
         else:
-            weight = self.ones(x.shape[1], x.dtype)
+            weight = self.generate_ones(x.dtype, x.astype('float32')[0].shape, 1)
         loss = self.multi_margin_loss(x, target, weight)
         return loss
 
@@ -1273,12 +1423,13 @@ class BCELoss(LossBase):
         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: 'none'.
+            Its value must be one of 'none', 'mean', 'sum'. Default: 'mean'.
 
     Inputs:
         - **logits** (Tensor) - The input tensor with shape :math:`(N, *)` where :math:`*` means, any number
           of additional dimensions. The data type must be float16 or float32.
-        - **labels** (Tensor) - The label tensor with shape :math:`(N, *)`, the same shape and data type as `logits`.
+        - **labels** (Tensor) - The label tensor with shape :math:`(N, *)` where :math:`*` means, any number
+          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`.
@@ -1302,9 +1453,9 @@ class BCELoss(LossBase):
         1.8952923
     """
 
-    def __init__(self, weight=None, reduction='none'):
+    def __init__(self, weight=None, reduction='mean'):
         """Initialize BCELoss."""
-        super(BCELoss, self).__init__()
+        super(BCELoss, self).__init__(reduction)
         self.binary_cross_entropy = P.BinaryCrossEntropy(reduction=reduction)
         self.weight_one = weight is None
         if not self.weight_one:
@@ -1323,7 +1474,7 @@ class BCELoss(LossBase):
         return loss
 
 
-@constexpr
+@_primexpr
 def _check_reduced_shape_valid(ori_shape, reduced_shape, axis, cls_name, arg_name1, arg_name2):
     """Internal function, used to check whether the reduced shape meets the requirements."""
     validator.check_reduce_shape(ori_shape, reduced_shape, axis, cls_name, arg_name1, arg_name2)
@@ -1381,7 +1532,7 @@ class CosineEmbeddingLoss(LossBase):
         self.reduce_sum = P.ReduceSum()
         self.maximum = P.Maximum()
         validator.check_value_type("margin", margin, [float], self.cls_name)
-        self.margin = validator.check_float_range(margin, -1.0, 1.0, Rel.INC_BOTH, "margin", self.cls_name)
+        self.margin = validator.check_float_range(margin, -1.0, 1.0, validator.INC_BOTH, "margin", self.cls_name)
 
     def construct(self, logits_x1, logits_x2, labels):
         _check_is_tensor('logits_x1', logits_x1, self.cls_name)
@@ -1409,12 +1560,12 @@ class CosineEmbeddingLoss(LossBase):
 
 class MultilabelMarginLoss(LossBase):
     r"""
-    MultilabelMarginLoss operation.
+    Creates a loss criterion that minimizes the hinge loss for multi-class
+    classification tasks.
+    It takes a 2D mini-batch Tensor :math:`x` as input and a 2D
+    Tensor :math:`y` containing target class indices as output.
 
-    Creates a criterion that optimizes a multi-class multi-classification
-    hinge loss (margin-based loss) between input :math:`x` (a 2D mini-batch `Tensor`)
-    and output :math:`y` (which is a 2D `Tensor` of target class indices).
-    For each sample in the mini-batch:
+    Each sample in the mini-batch, the loss is computed as follows:
 
     .. math::
         \text{loss}(x, y) = \sum_{ij}\frac{\max(0, 1 - (x[y[j]] - x[i]))}{\text{x.size}(0)}
@@ -1422,17 +1573,18 @@ class MultilabelMarginLoss(LossBase):
     where :math:`x \in \left\{0, \; \cdots , \; \text{x.size}(0) - 1\right\}`, \
     :math:`y \in \left\{0, \; \cdots , \; \text{y.size}(0) - 1\right\}`, \
     :math:`0 \leq y[j] \leq \text{x.size}(0)-1`, \
-    and :math:`i \neq y[j]` for all :math:`i` and :math:`j`.
-
-    :math:`y` and :math:`x` must have the same size.
+    and for all :math:`i` and :math:`j`, :math:`i` does not equal to :math:`y[j]`.
 
-    The criterion only considers a contiguous block of non-negative targets that
-    starts at the front.
+    Furthermore, both :math:`y` and :math:`x` should have identical sizes.
 
-    This allows for different samples to have variable amounts of target classes.
+    Note:
+        For this operator, only a contiguous sequence of non-negative targets that starts at
+        the beginning is taken into consideration, which means that different samples can have different
+        number of target classes.
 
     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".
 
     Inputs:
         - **x** (Tensor) - Predict data. Tensor of shape :math:`(C)` or :math:`(N, C)`, where :math:`N`
@@ -1443,8 +1595,6 @@ class MultilabelMarginLoss(LossBase):
     Outputs:
         - **y** (Union[Tensor, Scalar]) - The loss of MultilabelMarginLoss. If `reduction` is "none", its shape
           is :math:`(N)`. Otherwise, a scalar value will be returned.
-        - **is_target** (Tensor) - Output tensor for backward input, with the same shape as `target`,
-          data type must be int32.
 
     Raises:
         TypeError: If `x` or `target` is not a Tensor.
@@ -1463,8 +1613,7 @@ class MultilabelMarginLoss(LossBase):
        >>> target = Tensor(np.array([[1, 2, 0, 3], [2, 3, -1, 1]]), mindspore.int32)
        >>> output = loss(x, target)
        >>> print(output)
-       (Tensor(shape=[], dtype=Float32, value= 0.325), Tensor(shape=[2, 4], dtype=Int32, value=
-       [[1, 1, 1, 1], [0, 0, 1, 1]]))
+       Tensor(shape=[], dtype=Float32, value=0.325)
     """
 
     def __init__(self, reduction='mean'):
@@ -1472,7 +1621,8 @@ class MultilabelMarginLoss(LossBase):
         self.multilabel_margin_loss = MultilabelMarginLossOp(reduction=reduction)
 
     def construct(self, x, target):
-        return self.multilabel_margin_loss(x, target)
+        loss, _ = self.multilabel_margin_loss(x, target)
+        return loss
 
 
 class BCEWithLogitsLoss(LossBase):
@@ -1510,7 +1660,8 @@ class BCEWithLogitsLoss(LossBase):
     Inputs:
         - **logits** (Tensor) - Input logits with shape :math:`(N, *)` where :math:`*` means, any number
           of additional dimensions. The data type must be float16 or float32.
-        - **labels** (Tensor) - Ground truth label with shape :math:`(N, *)`, same shape and dtype as `logits`.
+        - **labels** (Tensor) - Ground truth label with shape :math:`(N, *)` where :math:`*` means, any number
+          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`.
@@ -1566,7 +1717,7 @@ class BCEWithLogitsLoss(LossBase):
         return loss
 
 
-@constexpr
+@_primexpr
 def _check_ndim(logits_nidm, labels_ndim, prime_name=None):
     '''Internal function, used to check whether the dimension of logits and labels meets the requirements.'''
     msg_prefix = f'For \'{prime_name}\', the' if prime_name else "The"
@@ -1581,7 +1732,7 @@ def _check_ndim(logits_nidm, labels_ndim, prime_name=None):
                          f"dimension of 'logits' {logits_nidm} and dimension of 'labels' {labels_ndim}.")
 
 
-@constexpr
+@_primexpr
 def _check_channel_and_shape(logits, labels, prime_name=None):
     '''Internal function, used to check whether the channels or shape of logits and labels meets the requirements.'''
     msg_prefix = f'For \'{prime_name}\', the' if prime_name else "The"
@@ -1711,18 +1862,6 @@ class FocalLoss(LossBase):
         return self.get_loss(loss)
 
 
-@constexpr
-def _dtype_check(logits_dtype, labels_dtype, prim_name):
-    """Check dtype."""
-    if logits_dtype not in [mstype.float32, mstype.float16]:
-        raise TypeError("For {}, the logits_dtype must be float32 or float16, but got {}.".format(prim_name,
-                                                                                                  logits_dtype))
-    if logits_dtype != labels_dtype:
-        raise TypeError("For {}, the labels_dtype must equal to logits_dtype {}, but got {}".format(prim_name,
-                                                                                                    logits_dtype,
-                                                                                                    labels_dtype))
-
-
 class HuberLoss(LossBase):
     r"""
     HuberLoss calculate the error between the predicted value and the target value.
@@ -1803,47 +1942,28 @@ class HuberLoss(LossBase):
     def __init__(self, reduction='mean', delta=1.0):
         """Initialize HuberLoss."""
         super(HuberLoss, self).__init__(reduction=reduction)
-        validator.check_value_type('delta', delta, [float, int], self.cls_name)
-        validator.check_number("delta", delta, 0.0, Rel.GT, self.cls_name)
-        self.sub = P.Sub()
-        self.mul = P.Mul()
-        self.abs = P.Abs()
-        self.less = P.Less()
-        self.square = P.Square()
-        self.select = P.Select()
-        self.dtype = P.DType()
+        self.reduction = reduction
         self.delta = delta
-        self.delta_half = 0.5 * self.delta
 
     def construct(self, logits, labels):
-        _check_is_tensor('logits', logits, self.cls_name)
-        _check_is_tensor('labels', labels, self.cls_name)
-        logits_dtype = self.dtype(logits)
-        labels_dtype = self.dtype(labels)
-        _dtype_check(logits_dtype, labels_dtype, self.cls_name)
-        z = self.abs(self.sub(logits, labels))
-        condition = self.less(z, self.delta)
-        l1 = self.mul(0.5, self.square(z))
-        l2 = self.mul(self.delta, self.sub(z, self.delta_half))
-        loss = self.select(condition, l1, l2)
-
-        return self.get_loss(loss)
+        return F.huber_loss(logits, labels, self.reduction, self.delta)
 
 
 class TripletMarginLoss(LossBase):
     r"""
     TripletMarginLoss operation.
 
-    Creates a criterion that measures the triplet loss given an input
-    tensors :math:`x1`, :math:`x2`, :math:`x3` and a margin with a value greater than :math:`0`.
-    This is used for measuring a relative similarity between samples. A triplet
-    is composed by `a`, `p` and `n` (i.e., `anchor`, `positive examples` and `negative
-    examples` respectively). The shapes of all input tensors should be
-    :math:`(N, D)`.
+    Triple loss is used to measure the relative similarity between samples,
+    which is measured by a triplet and a :math:`margin` with a value greater than :math:`0` .
+    The triplet is composed by :math:`a`, :math:`p`, :math:`n` in the following formula.
 
-    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.
+    The shapes of all input tensors should be :math:`(N, *)` , where :math:`N` is batch size
+    and :math:`*` means any number of additional dimensions.
+
+    The distance swap is described in detail in the paper
+    `Learning local feature descriptors with triplets and shallow convolutional neural
+    networks <http://158.109.8.37/files/BRP2016.pdf>`_
+    by V. Balntas, E. Riba et al.
 
     The loss function for each sample in the mini-batch is:
 
@@ -1856,28 +1976,30 @@ class TripletMarginLoss(LossBase):
         d(x_i, y_i) = \left\lVert {\bf x}_i - {\bf y}_i \right\rVert_p
 
     Args:
-        p (int): The norm degree for pairwise distance. Default: 2.
-        eps (float): Default: 1e-06.
-        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".
+        p (int, optional): The degree of norm for pairwise distance. Default: 2.
+        eps (float, optional): Add small value to avoid division by zero. Default: 1e-06.
+        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".
+        margin (Union[Tensor, float]) - Make a margin between the positive pair and the negative pair. Default: 1.0.
 
     Inputs:
         - **x** (Tensor) - A sample randomly selected from the training set. Data type must be BasicType.
-        - **positive** (Tensor) - A sample belonging to the same category as x, with the same type and shape as `x`.
-        - **negative** (Tensor) - A sample belonging to the different class from x, with the same type and shape as `x`.
-        - **margin** (Tensor) - Make a margin between the positive pair and the negative pair.
+          :math:`a` in the above formula.
+        - **positive** (Tensor) - A sample belonging to the same category as `x`, with the same type and
+          shape as `x`. :math:`p` in the above formula.
+        - **negative** (Tensor) - A sample belonging to the different class from `x`, with the same type and shape
+          as `x`. :math:`n` in the above formula.
+        - **margin** (Union[Tensor, float]) - Make a margin between the positive pair and the negative pair.
+          Default: 1.0.
 
     Outputs:
-        Union[Tensor, Scalar], 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' or 'margin' is not a Tensor.
-        TypeError: If dtype of `x` or `positive` or `negative` is not BasicType.
+        TypeError: If `x` or `positive` or 'negative' is not a Tensor.
         TypeError: If dtype of `x`, `positive` and `negative` is not the same.
-        TypeError: If `margin` is not float32.
         TypeError: If `p` is not an int.
         TypeError: If `eps` is not a float.
         TypeError: If `swap` is not a bool.
@@ -1888,25 +2010,31 @@ class TripletMarginLoss(LossBase):
         ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU`
+        ``GPU``
 
     Examples:
         >>> loss = nn.TripletMarginLoss()
         >>> x = Tensor(np.array([[0.3, 0.7], [0.5, 0.5]]), mindspore.float32)
         >>> positive = Tensor(np.array([[0.4, 0.6], [0.4, 0.6]]), mindspore.float32)
         >>> negative = Tensor(np.array([[0.2, 0.9], [0.3, 0.7]]), mindspore.float32)
-        >>> margin = Tensor(1.0, mindspore.float32)
-        >>> output = loss(x, positive, negative, margin)
+        >>> output = loss(x, positive, negative)
         >>> print(output)
         0.8881968
     """
 
-    def __init__(self, p=2, swap=False, eps=1e-6, reduction='mean'):
+    def __init__(self, p=2, swap=False, eps=1e-06, reduction='mean', margin=1.):
         super(TripletMarginLoss, self).__init__()
-        self.triplet_margin_loss = TripletMarginLossOp(p=p, swap=swap, eps=eps, reduction=reduction)
+        self.p = p
+        self.swap = swap
+        self.eps = eps
+        self.reduction = reduction
+        self.margin = margin
 
-    def construct(self, x, positive, negative, margin):
-        return self.triplet_margin_loss(x, positive, negative, margin)
+    def construct(self, x, positive, negative, margin=1.):
+        if self.margin != 1.0:
+            margin = self.margin
+        return F.triplet_margin_loss(x, positive, negative, margin=margin, p=self.p,
+                                     eps=self.eps, swap=self.swap, reduction=self.reduction)
 
 
 @constexpr
@@ -1927,7 +2055,7 @@ class NLLLoss(LossBase):
     r"""
     Gets the negative log likelihood loss between logits and labels.
 
-    The nll loss with reduction=none can be described as:
+    The nll loss with :math:`reduction = none` can be described as:
 
     .. math::
 
@@ -2020,11 +2148,12 @@ def _check_cross_entropy_inputs(logits_shape, label_shape,
                              f"but get 'logits' shape: {logits_shape} and 'labels' shape: {label_shape}.")
     elif label_rank == logits_rank - 1:
         validator.check_type_name('labels', label_dtype, [mstype.int32], prim_name)
-        logits_shape_new = (logits_shape[0], *logits_shape[2:])
-        if logits_shape_new != label_shape:
-            raise ValueError(f"{msg_prefix} shape of 'logits' should be (N, C, d_0, d_1, ...), "
-                             f"and the shape of 'labels' should be (N, d_0, d_1, ...), "
-                             f"but get 'logits' shape: {logits_shape} and 'labels' shape: {label_shape}.")
+        if logits_rank != 1:
+            logits_shape_new = (logits_shape[0], *logits_shape[2:])
+            if logits_shape_new != label_shape:
+                raise ValueError(f"{msg_prefix} shape of 'logits' should be (N, C, d_0, d_1, ...), "
+                                 f"and the shape of 'labels' should be (N, d_0, d_1, ...), "
+                                 f"but get 'logits' shape: {logits_shape} and 'labels' shape: {label_shape}.")
     else:
         raise ValueError(f"{msg_prefix} rank of 'logits' and 'labels' should be:\n"
                          f"1. 'logits.ndim == labels.ndim' for probabilities, \n"
@@ -2141,7 +2270,7 @@ class CrossEntropyLoss(LossBase):
         super().__init__(reduction)
         validator.check_value_type('ignore_index', ignore_index, int, self.cls_name)
         validator.check_value_type('label_smoothing', label_smoothing, float, self.cls_name)
-        validator.check_float_range(label_smoothing, 0.0, 1.0, Rel.INC_BOTH, 'label_smoothing', self.cls_name)
+        validator.check_float_range(label_smoothing, 0.0, 1.0, validator.INC_BOTH, 'label_smoothing', self.cls_name)
 
         if weight is not None:
             validator.check_value_type("weight", weight, [Tensor], self.cls_name)
@@ -2166,7 +2295,7 @@ class CrossEntropyLoss(LossBase):
 
 class KLDivLoss(LossBase):
     r"""
-    Computes the Kullback-Leibler divergence between the logits and the labels.
+    Computes the Kullback-Leibler divergence between the `logits` and the `labels`.
 
     For tensors of the same shape :math:`x` and :math:`target`,
     the updating formulas of KLDivLoss algorithm are as follows,
@@ -2240,41 +2369,44 @@ class KLDivLoss(LossBase):
 
 class CTCLoss(LossBase):
     """
-    Calculates the CTC (Connectionist Temporal Classification) loss.
+    Calculates the CTC (Connectionist Temporal Classification) loss. It's mainly used to calculate the loss between
+    the continuous, unsegemented time series and the target series.
 
     For the CTC algorithm, refer to `Connectionist Temporal Classification: Labeling Unsegmented Sequence Data with
     Recurrent Neural Networks <http://www.cs.toronto.edu/~graves/icml_2006.pdf>`_ .
 
     Args:
-        blank (int): The blank label. Default: 0.
-        reduction (str): Apply specific reduction method to the output: 'none', 'mean', or 'sum'. Default: 'mean'.
-        zero_infinity (bool): Whether to set infinite loss and correlation gradient to zero. Default: False.
+        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'.
+        zero_infinity (bool, optional): If loss is infinite, this parameter determines whether to set that loss
+            and its correlated gradient to zero. Default: False.
 
     Inputs:
-        - **log_probs** (Tensor) - A tensor of shape (T, N, C) or (T, C), where T is input length, N is batch size and
-          C is number of classes (including blank). T, N and C are positive integers.
-        - **targets** (Tensor) - A tensor of shape (N, S) or (sum( `target_lengths` )), where S is max target length,
-          means the target sequences.
-        - **input_lengths** (Union[tuple, Tensor, int]) - A tuple or Tensor of shape(N), or a number.
-          It means the lengths of the input.
-        - **target_lengths** (Union[tuple, Tensor, int]) - A tuple or Tensor of shape(N), or a number.
-          It means the lengths of the target.
+        - **log_probs** (Tensor) - A tensor of shape :math:`(T, N, C)` or :math:`(T, C)`, where T is length of input,
+          N is size of the batch and C is the number of classes. T, N and C are positive integers.
+        - **targets** (Tensor) - A tensor of shape :math:`(N, S)` or (sum( `target_lengths` )),
+          where S is max target length, means the target sequences.
+        - **input_lengths** (Union[tuple, Tensor]) - A tuple or Tensor of shape(N). It means the lengths of the input.
+        - **target_lengths** (Union[tuple, Tensor]) - A tuple or Tensor of shape(N). It means the lengths of the target.
 
     Outputs:
         - **neg_log_likelihood** (Tensor) - A loss value which is differentiable with respect to each input node.
 
     Raises:
+        TypeError: If `log_probs` or `targets` is not a Tensor.
         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 the types of `targets`, `input_lengths` or `target_lengths` are different.
         ValueError: If the value of `blank` is not in range [0, C). C is number of classes of `log_probs` .
-        ValueError: If any value of `input_lengths` is larger than C. C is number of classes of `log_probs` .
-        ValueError: If any target_lengths[i] is not in range [0, input_length[i]].
+        ValueError: If the dimension of `targets` is not one when the shape of `log_prob` is :math:`(T, C)`.
+        RuntimeError: If any value of `input_lengths` is larger than T. T is length of `log_probs` .
+        RuntimeError: If any target_lengths[i] is not in range [0, input_length[i]].
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -2297,62 +2429,65 @@ class CTCLoss(LossBase):
         >>> ctc_loss = CTCLoss(blank=0, reduction='none', zero_infinity=False)
         >>> loss = ctc_loss(ms_input, target, input_lengths, target_lengths)
         >>> print(loss)
-        Tensor(shape=[2], dtype=Float32, value= [-4.57949715e+001, -5.57949677e+001])
+        [-45.79497  -55.794968]
         >>> arr = np.arange(T*C).reshape((T, C))
         >>> ms_input = Tensor(arr, dtype=mstype.float32)
-        >>> input_lengths = T
-        >>> target_lengths = S_min
+        >>> input_lengths = Tensor([T], dtype=mstype.int32)
+        >>> target_lengths = Tensor([S_min], dtype=mstype.int32)
         >>> target = np.random.randint(1, C, size=(S_min,))
         >>> target = Tensor(target, dtype=mstype.int32)
         >>> ctc_loss = CTCLoss(blank=0, reduction='none', zero_infinity=False)
         >>> loss = ctc_loss(ms_input, target, input_lengths, target_lengths)
         >>> print(loss)
-        Tensor(shape=[1], dtype=Float32, value= [-2.57949677e+001])
+        -25.794968
     """
 
     def __init__(self, blank=0, reduction='mean', zero_infinity=False):
-        super().__init__(reduction)
-        self.ctcloss = CTCLossV2(blank=blank, reduction='none', zero_infinity=zero_infinity)
+        super().__init__()
+        self.blank = blank
+        self.reduction = reduction
+        self.zero_infinity = zero_infinity
 
     def construct(self, log_probs, targets, input_lengths, target_lengths):
-        if len(log_probs.shape) == 2:
-            n, c = log_probs.shape
-            log_probs = log_probs.reshape((n, 1, c))
-            targets = targets.reshape(1, targets.shape[0])
-            if isinstance(input_lengths, int):
-                input_lengths = Tensor([input_lengths], mstype.int32)
-            else:
-                raise ValueError("The dtype of input_lengths should be int32 or int64.")
-            if isinstance(target_lengths, int):
-                target_lengths = Tensor([target_lengths], mstype.int32)
-            else:
-                raise ValueError("The dtype of target_lengths should be int32 or int64.")
-        neg_log_hood, _ = self.ctcloss(log_probs, targets, input_lengths, target_lengths)
-        return self.get_loss(neg_log_hood)
+        _check_is_tensor('log_probs', log_probs, self.cls_name)
+        _check_is_tensor('targets', targets, self.cls_name)
+        if log_probs.ndim == 2:
+            if targets.ndim > 1:
+                raise ValueError("For CTCLoss, when the shape of log_probs is (T, C), the dimension of targets should"
+                                 "be equal to one.")
+            log_probs = log_probs.expand_dims(-2)
+            targets = targets.expand_dims(0)
+            neg_log_hood, _ = F.ctc_loss(log_probs, targets, input_lengths, target_lengths, self.blank, self.reduction,
+                                         self.zero_infinity)
+            return neg_log_hood.squeeze()
+        neg_log_hood, _ = F.ctc_loss(log_probs, targets, input_lengths, target_lengths, self.blank, self.reduction,
+                                     self.zero_infinity)
+        return neg_log_hood
 
 
 class GaussianNLLLoss(LossBase):
-    r"""Gaussian negative log likelihood loss.
+    r"""
+    Gaussian negative log likelihood loss.
 
-    The targets are treated as samples from Gaussian distributions with expectations and variances predicted by the
-    neural network. For a `labels` tensor modelled as having Gaussian distribution with a tensor of expectations
-    `logits` and a tensor of positive variances `var` the loss is:
+    The target values are considered to be samples from a Gaussian distribution, where the expectation and variance are
+    predicted by a neural network. For `labels` modeled on a Gaussian distribution, `logits` to record expectations,
+    and the variance `var` (elements are all positive), the calculated loss is:
 
     .. math::
         \text{loss} = \frac{1}{2}\left(\log\left(\text{max}\left(\text{var},
         \ \text{eps}\right)\right) + \frac{\left(\text{logits} - \text{labels}\right)^2}
         {\text{max}\left(\text{var}, \ \text{eps}\right)}\right) + \text{const.}
 
-    where `eps` is used for stability of :math:`log`. By default, the constant term of the loss function is omitted
-    unless :math:`full=True`. If the shape of :math:`var` is not the same as `logits` (due to a
-    homoscedastic assumption), it must either have a final dimension of 1 or have one fewer dimension
-    (with all other sizes being the same) for correct broadcasting.
+    where :math:`eps` is used for stability of :math:`log`. When :math:`full=True`, a constant will be added to
+    the loss. If the shape of :math:`var` and :math:`logits` are not the same (due to a homoscedastic assumption),
+    their shapes must allow correct broadcasting.
 
-    Args:
-        full (bool): 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): Used to improve the stability of log function. Default: 1e-6.
-        reduction (str): Apply specific reduction method to the output: 'none', 'mean', or 'sum'. Default: 'mean'.
+    Keyword Args:
+        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 'sum'.
+            Default: 'mean'.
 
     Inputs:
         - **logits** (Tensor) - Tensor of shape :math:`(N, *)` or :math:`(*)` where :math:`*` means any number of
@@ -2364,14 +2499,14 @@ class GaussianNLLLoss(LossBase):
           (to allow for broadcasting).
 
     Returns:
-        Tensor or Tensor scalar, the computed loss depending on `reduction`.
+        Tensor or Tensor scalar, the computed loss depending on :math:`reduction`.
 
     Raises:
         TypeError: If `logits` is not a Tensor.
         TypeError: If `labels` is not a Tensor.
         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 `eps` is not a float within (0, inf).
         ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
 
     Supported Platforms:
@@ -2401,7 +2536,7 @@ class GaussianNLLLoss(LossBase):
 
     def __init__(self, *, full=False, eps=1e-6, reduction='mean'):
         super(GaussianNLLLoss, self).__init__()
-        validator.check_float_range(eps, 0, float('inf'), Rel.INC_NEITHER, "eps", self.cls_name)
+        validator.check_float_range(eps, 0, float('inf'), validator.INC_NEITHER, "eps", self.cls_name)
         validator.check_value_type('full', full, [bool], self.cls_name)
         validator.check_string(reduction, ['none', 'mean', 'sum'], 'reduction', 'gaussian_nll_loss')
         self.full = full
@@ -2417,9 +2552,8 @@ class GaussianNLLLoss(LossBase):
 
 class HingeEmbeddingLoss(LossBase):
     r"""
-    Hinge Embedding Loss. Compute the output according to the input elements. Measures the loss given an input tensor x
-    and a labels tensor y (containing 1 or -1).
-    This is usually used for measuring the similarity between two inputs.
+    Calculate the Hinge Embedding Loss value based on the input 'logits' and' labels' (only including 1 or -1).
+    Usually used to measure the similarity between two inputs.
 
     The loss function for :math:`n`-th sample in the mini-batch is
 
@@ -2440,29 +2574,30 @@ class HingeEmbeddingLoss(LossBase):
     where :math:`L = \{l_1,\dots,l_N\}^\top`.
 
     Args:
-        margin (float): Threshold defined by Hinge Embedding Loss :math:`margin`.
+        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 'sum'.
             Default: 'mean'.
 
     Inputs:
-        - **logits** (Tensor) - Tensor of shape :math:`(*)` where :math:`*` means any number of dimensions.
+        - **logits** (Tensor) - The predicted value, expressed as :math:`x` in the equation.
+          Tensor of shape :math:`(*)` where :math:`*` means any number of dimensions.
         - **labels** (Tensor) - Same shape as the logits, contains -1 or 1.
 
     Returns:
-        Tensor or Tensor scalar, the computed loss depending on `reduction`.
+        Tensor or Tensor scalar, the computed loss depending on :math:`reduction`.
 
     Raises:
         TypeError: If `logits` is not a Tensor.
         TypeError: If `labels` is not a Tensor.
-        TypeError: If `margin` is not a float.
-        ValueError: If `labels` does not have the same shape as `logits`.
+        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'.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
-    Examplse:
+    Examples:
         >>> import numpy as np
         >>> from mindspore import Tensor
         >>> import mindspore.nn as nn
@@ -2479,7 +2614,7 @@ class HingeEmbeddingLoss(LossBase):
 
     def __init__(self, margin=1.0, reduction='mean'):
         super(HingeEmbeddingLoss, self).__init__()
-        validator.check_value_type('margin', margin, [float], self.cls_name)
+        validator.check_value_type('margin', margin, [float, int], self.cls_name)
         validator.check_string(reduction, ['none', 'sum', 'mean'], 'reduction', self.cls_name)
         self.margin = margin
         self.reduction = reduction