mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/nn/loss/loss.py

@@ -13,24 +13,25 @@
 # limitations under the License.
 # ============================================================================
 """loss"""
-from __future__ import absolute_import
+from __future__ import absolute_import, division
+import math
 
 import mindspore
 import mindspore.common.dtype as mstype
+import mindspore.ops as ops
 from mindspore import log
 from mindspore.common.tensor import Tensor
 from mindspore.common.parameter import Parameter
 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 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
 
 
@@ -245,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):
@@ -457,6 +455,79 @@ class MAELoss(LossBase):
         return self.get_loss(x)
 
 
+class MarginRankingLoss(LossBase):
+    r"""
+    MarginRankingLoss creates a criterion that measures the loss.
+
+    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}(input1, input2, target) = \max(0, -target * (input1 - input2) + \text{margin})
+
+    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".
+
+    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 `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`.
+        Otherwise, a scalar value will be returned.
+
+    Raises:
+        TypeError: If `margin` is not a float.
+        TypeError: If `input1`, `input2` or `target` is not a Tensor.
+        TypeError: If the types of `input1` and `input2` are inconsistent.
+        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'.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> import mindspore.nn as nn
+        >>> import mindspore.ops as ops
+        >>> from mindspore.ops import Tensor
+        >>> import numpy as np
+        >>> loss1 = nn.MarginRankingLoss(reduction='none')
+        >>> loss2 = nn.MarginRankingLoss(reduction='mean')
+        >>> loss3 = nn.MarginRankingLoss(reduction='sum')
+        >>> sign = ops.Sign()
+        >>> input1 = Tensor(np.array([0.3864, -2.4093, -1.4076]), ms.float32)
+        >>> input2 = Tensor(np.array([-0.6012, -1.6681, 1.2928]), ms.float32)
+        >>> target = sign(Tensor(np.array([-2, -2, 3]), ms.float32))
+        >>> output1 = loss1(input1, input2, target)
+        >>> print(output1)
+        [0.98759997 0.         2.7003999 ]
+        >>> output2 = loss2(input1, input2, target)
+        >>> print(output2)
+        1.2293333
+        >>> output3 = loss3(input1, input2, target)
+        >>> print(output3)
+        3.6879997
+    """
+
+    def __init__(self, margin=0.0, reduction='mean'):
+        """Initialize MarginRankingLoss."""
+        super(MarginRankingLoss, self).__init__(reduction)
+        self.reduction = reduction
+        self.margin = margin
+
+    def construct(self, input1, input2, target):
+        x = ops.margin_ranking_loss(input1, input2, target, self.margin, self.reduction)
+        return x
+
+
 class SmoothL1Loss(LossBase):
     r"""
     SmoothL1 loss function, if the absolute error element-wise between the predicted value and the target value
@@ -502,7 +573,7 @@ class SmoothL1Loss(LossBase):
 
     Outputs:
         Tensor, if `reduction` is 'none', then output is a tensor with the same shape as `logits`.
-        Otherwise the shape of output tensor is `(1,)`.
+        Otherwise the shape of output tensor is `()`.
 
     Raises:
         TypeError: If `beta` is not a float.
@@ -568,7 +639,7 @@ class SoftMarginLoss(LossBase):
         ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``GPU``
 
     Examples:
         >>> loss = nn.SoftMarginLoss()
@@ -594,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:
 
@@ -619,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:
@@ -703,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:
@@ -751,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"
@@ -767,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"
@@ -994,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,
@@ -1089,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
@@ -1100,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,)`.
@@ -1138,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)
@@ -1149,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
 
@@ -1197,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`.
@@ -1226,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:
@@ -1247,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)
@@ -1305,13 +1532,13 @@ 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)
         _check_is_tensor('logits_x2', logits_x2, self.cls_name)
         _check_is_tensor('labels', labels, self.cls_name)
-        F.same_type_shape(logits_x1, logits_x2)
+        inner.same_type_shape_(logits_x1, logits_x2)
         _check_reduced_shape_valid(F.shape(logits_x1), F.shape(labels), (1,), self.cls_name, "logits_x1", "labels")
         # if labels > 0, 1-cosine(logits_x1, logits_x2)
         # else, max(0, cosine(logits_x1, logits_x2)-margin)
@@ -1333,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)}
@@ -1346,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`.
+    and for all :math:`i` and :math:`j`, :math:`i` does not equal to :math:`y[j]`.
 
-    :math:`y` and :math:`x` must have the same size.
+    Furthermore, both :math:`y` and :math:`x` should have identical sizes.
 
-    The criterion only considers a contiguous block of non-negative targets that
-    starts at the front.
-
-    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`
@@ -1367,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.
@@ -1379,7 +1605,7 @@ class MultilabelMarginLoss(LossBase):
         ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``GPU``
 
     Examples:
        >>> loss = nn.MultilabelMarginLoss()
@@ -1387,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'):
@@ -1396,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):
@@ -1434,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`.
@@ -1490,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"
@@ -1505,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"
@@ -1635,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.
@@ -1727,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 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 shallow
-    convolutional feature descriptors with triplet losses` by
-    V. Balntas, E. Riba et al.
+    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:
 
@@ -1780,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.
@@ -1812,25 +2010,31 @@ class TripletMarginLoss(LossBase):
         ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
 
     Supported Platforms:
-        ``Ascend`` ``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
@@ -1851,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::
 
@@ -1928,9 +2132,9 @@ class NLLLoss(LossBase):
 
 
 @constexpr
-def _check_cross_entropy_inputs(logits_shape, label_shape, \
-                                logits_rank, label_rank, \
-                                logits_dtype, label_dtype, \
+def _check_cross_entropy_inputs(logits_shape, label_shape,
+                                logits_rank, label_rank,
+                                logits_dtype, label_dtype,
                                 prim_name=None):
     """Internal function, used to check whether the shape of logits and labels meets the requirements."""
     validator.check_type_name('logits', logits_dtype, [mstype.float16, mstype.float32], prim_name)
@@ -1944,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"
@@ -1958,7 +2163,7 @@ def _check_cross_entropy_inputs(logits_shape, label_shape, \
 
 @constexpr
 def _cross_entropy_ignore_index_warning(prim_name):
-    """Internal function, used to warrning when ignore_index > 0 for probabilities."""
+    """Internal function, used to warning when ignore_index > 0 for probabilities."""
     log.warning(f"For \'{prim_name}\', 'ignore_index' does not work when 'labels' is Probability.")
 
 
@@ -2065,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)
@@ -2079,10 +2284,341 @@ class CrossEntropyLoss(LossBase):
     def construct(self, logits, labels):
         _check_is_tensor('logits', logits, self.cls_name)
         _check_is_tensor('labels', labels, self.cls_name)
-        _check_cross_entropy_inputs(logits.shape, labels.shape, \
-                                    logits.ndim, labels.ndim, \
-                                    logits.dtype, labels.dtype, \
+        _check_cross_entropy_inputs(logits.shape, labels.shape,
+                                    logits.ndim, labels.ndim,
+                                    logits.dtype, labels.dtype,
                                     self.cls_name)
         if logits.ndim == labels.ndim and self.ignore_index > 0:
             _cross_entropy_ignore_index_warning(self.cls_name)
         return F.cross_entropy(logits, labels, self.weight, self.ignore_index, self.reduction, self.label_smoothing)
+
+
+class KLDivLoss(LossBase):
+    r"""
+    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,
+
+    .. math::
+        L(x, target) = target \cdot (\log target - x)
+
+    Then,
+
+    .. math::
+        \ell(x, target) = \begin{cases}
+        L(x, target), & \text{if reduction} = \text{'none';}\\
+        \operatorname{mean}(L(x, target)), & \text{if reduction} = \text{'mean';}\\
+        \operatorname{sum}(L(x, target)) / x.\operatorname{shape}[0], & \text{if reduction} = \text{'batchmean';}\\
+        \operatorname{sum}(L(x, target)),  & \text{if reduction} = \text{'sum'.}
+        \end{cases}
+
+    where :math:`x` represents `logits`,
+    :math:`target` represents `labels`, and
+    :math:`\ell(x, target)` represents `output`.
+
+    Note:
+        - Currently it does not support float64 input on `Ascend`.
+        - The output aligns with the mathematical definition of Kullback-Leibler divergence
+          only when `reduction` is set to 'batchmean'.
+
+    Args:
+        reduction (str): Specifies the reduction to be applied to the output.
+            Default: 'mean'.
+
+            - On Ascend, the value of `reduction` must be one of 'batchmean', 'none' or 'sum'.
+            - On GPU, the value of `reduction` must be one of 'mean', 'none' or 'sum'.
+            - On CPU, the value of `reduction` must be one of 'mean', 'batchmean', 'none' or 'sum'.
+
+    Inputs:
+        - **logits** (Tensor) - The input Tensor. The data type must be float16, float32 or float64.
+        - **labels** (Tensor) - The label Tensor which has the same shape and data type as `logits`.
+
+    Outputs:
+        Tensor or Scalar, if `reduction` is 'none', then output is a tensor and has the same shape as `logits`.
+        Otherwise, it is a scalar.
+
+    Raises:
+        TypeError: If `reduction` is not a str.
+        TypeError: If neither `logits` nor `labels` is a Tensor.
+        TypeError: If dtype of `logits` or `labels` is not currently supported.
+        ValueError: If shape of `logits` is not the same as `labels`.
+        RuntimeError: If `logits` or `labels` is a scalar when `reduction` is 'batchmean'.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> logits = Tensor(np.array([0.2, 0.7, 0.1]), mindspore.float32)
+        >>> labels = Tensor(np.array([0., 1., 0.]), mindspore.float32)
+        >>> loss = nn.KLDivLoss(reduction='mean')
+        >>> output = loss(logits, labels)
+        >>> print(output)
+        -0.23333333
+    """
+
+    def __init__(self, reduction='mean'):
+        super().__init__()
+        self.reduction = reduction
+
+    def construct(self, logits, labels):
+        _check_is_tensor('logits', logits, self.cls_name)
+        _check_is_tensor('labels', labels, self.cls_name)
+        return F.kl_div(logits, labels, self.reduction)
+
+
+class CTCLoss(LossBase):
+    """
+    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, 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 :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 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`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore.nn.loss import CTCLoss
+        >>> T = 5      # Input sequence length
+        >>> C = 2      # Number of classes
+        >>> N = 2      # Batch size
+        >>> S = 3      # Target sequence length of longest target in batch (padding length)
+        >>> S_min = 2  # Minimum target length, for demonstration purposes
+        >>> arr = np.arange(T*N*C).reshape((T, N, C))
+        >>> ms_input = Tensor(arr, dtype=mstype.float32)
+        >>> input_lengths = np.full(shape=(N), fill_value=T)
+        >>> input_lengths = Tensor(input_lengths, dtype=mstype.int32)
+        >>> target_lengths = np.full(shape=(N), fill_value=S_min)
+        >>> target_lengths = Tensor(target_lengths, dtype=mstype.int32)
+        >>> target = np.random.randint(1, C, size=(N, S))
+        >>> 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)
+        [-45.79497  -55.794968]
+        >>> arr = np.arange(T*C).reshape((T, C))
+        >>> ms_input = Tensor(arr, dtype=mstype.float32)
+        >>> 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)
+        -25.794968
+    """
+
+    def __init__(self, blank=0, reduction='mean', zero_infinity=False):
+        super().__init__()
+        self.blank = blank
+        self.reduction = reduction
+        self.zero_infinity = zero_infinity
+
+    def construct(self, log_probs, targets, input_lengths, target_lengths):
+        _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.
+
+    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 :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.
+
+    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
+          additional dimensions.
+        - **labels** (Tensor) - Tensor of shape :math:`(N, *)` or :math:`(*)`, same shape as the logits, or same shape
+          as the logits but with one dimension equal to 1 (to allow for broadcasting).
+        - **var** - Tensor of shape :math:`(N, *)` or :math:`(*)`, same shape as logits, or same shape as the logits
+          but with one dimension equal to 1, or same shape as the logits but with one fewer dimension
+          (to allow for broadcasting).
+
+    Returns:
+        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 `reduction` is not one of 'none', 'mean', 'sum'.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> import mindspore.nn as nn
+        >>> import mindspore.common.dtype as mstype
+        >>> arr1 = np.arange(8).reshape((4, 2))
+        >>> arr2 = np.array([2, 3, 1, 4, 6, 4, 4, 9]).reshape((4, 2))
+        >>> logits = Tensor(arr1, mstype.float32)
+        >>> labels = Tensor(arr2, mstype.float32)
+        >>> loss = nn.GaussianNLLLoss(reduction='mean')
+        >>> var = Tensor(np.ones((4, 1)), mstype.float32)
+        >>> output = loss(logits, labels, var)
+        >>> print(output)
+        1.4374993
+
+    Reference:
+        Nix, D. A. and Weigend, A. S., "Estimating the mean and variance of the
+        target probability distribution", Proceedings of 1994 IEEE International
+        Conference on Neural Networks (ICNN'94), Orlando, FL, USA, 1994, pp. 55-60
+        vol.1, doi: 10.1109/ICNN.1994.374138.
+    """
+
+    def __init__(self, *, full=False, eps=1e-6, reduction='mean'):
+        super(GaussianNLLLoss, self).__init__()
+        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
+        self.eps = eps
+        self.reduction = reduction
+
+    def construct(self, logits, labels, var):
+        _check_is_tensor('logits', logits, self.cls_name)
+        _check_is_tensor('labels', labels, self.cls_name)
+        _check_is_tensor('var', var, self.cls_name)
+        return ops.gaussian_nll_loss(logits, labels, var, self.full, self.eps, self.reduction)
+
+
+class HingeEmbeddingLoss(LossBase):
+    r"""
+    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
+
+    .. math::
+        l_n = \begin{cases}
+        x_n, & \text{if}\; y_n = 1,\\
+        \max \{0, \Delta - x_n\}, & \text{if}\; y_n = -1,
+        \end{cases}
+
+    and the total loss functions is
+
+    .. math::
+        \ell(x, y) = \begin{cases}
+        \operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
+        \operatorname{sum}(L),  & \text{if reduction} = \text{'sum'.}
+        \end{cases}
+
+    where :math:`L = \{l_1,\dots,l_N\}^\top`.
+
+    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 'sum'.
+            Default: 'mean'.
+
+    Inputs:
+        - **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 :math:`reduction`.
+
+    Raises:
+        TypeError: If `logits` is not a Tensor.
+        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'.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> import mindspore.nn as nn
+        >>> import mindspore.common.dtype as mstype
+        >>> arr1 = np.array([0.9, -1.2, 2, 0.8, 3.9, 2, 1, 0, -1]).reshape((3, 3))
+        >>> arr2 = np.array([1, 1, -1, 1, -1, 1, -1, 1, 1]).reshape((3, 3))
+        >>> logits = Tensor(arr1, mstype.float32)
+        >>> labels = Tensor(arr2, mstype.float32)
+        >>> loss = nn.HingeEmbeddingLoss(reduction='mean')
+        >>> output = loss(logits, labels)
+        >>> print(output)
+        0.16666667
+    """
+
+    def __init__(self, margin=1.0, reduction='mean'):
+        super(HingeEmbeddingLoss, self).__init__()
+        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
+
+    def construct(self, logits, labels):
+        loss = ops.hinge_embedding_loss(logits, labels, self.margin, self.reduction)
+        return loss