
    ёiM                   x   % S SK Jr  S SKrS SKJrJrJr  S SKrS SKJrJ	r	J
r
  S SKJr  S SKJr  S SKJr  SS	KJrJr  SS
KJrJrJrJr  SSKJr  SSKJr  SSKJr  \(       a  S SKJ r   S SKJ!r!J"r"  S SKJ#r#  \S   r$S\%S'   / r&Sr'  SB         SCS jjr(  SD         SCS jjr)     SE               SFS jjr* SG         SHS jjr+SIS jr,    SJ             SKS jjr-   SL           SMS jjr.    SN             SOS jjr/     SP                   SQS jjr0    SR             SSS jjr1   ST             SUS  jjr2  SV         SWS! jjr3    SX             SYS" jjr4     SZ               S[S# jjr5   S\           S]S$ jjr6  SV         SWS% jjr7    S^                 S_S& jjr8    S`                 SaS' jjr9\       Sb                 ScS( jj5       r:\       Sb                 SdS) jj5       r:\       Sb                 SeS* jj5       r:       SfS+ jr:\     Sg               ShS, jj5       r;\     Sg               SiS- jj5       r;\     Sg               SjS. jj5       r;\" S/S0S1S2S39     SES4 j5       r;\" SS5/05              Sk                     SlS6 jj5       r<     Sm               SnS7 jjr=   SL           SMS8 jjr>   So           SpS9 jjr?   Sq             SrS: jjr@     Ss                 StS; jjrA      Su                   SvS< jjrB     Sw               SxS= jjrC  SV         SWS> jjrD  SV         SWS? jjrE    Sy               SzS@ jjrF  S{               S|SA jjrGg)}    )annotationsN)TYPE_CHECKINGLiteraloverload)_C_opsbasein_dynamic_mode)Assert)
deprecated)ParamAliasDecorator   )
check_typecheck_variable_and_dtype)_current_expected_placecorein_dynamic_or_pir_modein_pir_mode)LayerHelper)Variable)reshape)Sequence)Callable	TypeAlias)Tensormeansumnoner   _ReduceModelabelc                   U R                   [        R                  [        R                  4;   d   eUR                   [        R                  [        R
                  4;   d   e[        U R                  5      S:  d   S5       e[        U R                  5      [        UR                  5      :X  d4   S[        U R                  5       S[        UR                  5       S35       eUR                  S   S:X  d   SUR                  S    S35       eU R                  S	S UR                  S	S :X  d   S
5       e[        R                  " US/5      n[        R                  R                  R                  XR                  S   5      n[        [        S[        U R                  5      5      5      n[        R                  " X-  US9n[        R                  " XS9[        R                  " XS9-   nSUS-  Xb-   -  -
  n[        R                  " U5      $ )aX  

Dice loss for comparing the similarity between the input predictions and the label.
This implementation is for binary classification, where the input is sigmoid
predictions of each pixel, usually used for segmentation task. The dice loss can
be defined as the following equation:

.. math::

    dice\_loss &= 1 - \frac{2 * intersection\_area}{total\_area} \\
              &= \frac{(total\_area - intersection\_area) - intersection\_area}{total\_area} \\
              &= \frac{(union\_area - intersection\_area)}{total\_area}


Parameters:
    input (Tensor): Tensor, rank>=2, shape is :math:`[N_1, N_2, ..., N_k, D]`, where :math:`N_1` is
                      the batch_size, :math:`D` is the number of categories. It is usually the output
                      predictions of sigmoid activation. The data type can be float32 or float64.
    label (Tensor): Tensor, the ground truth with the same rank as input, shape is :math:`[N_1, N_2, ..., N_k, 1]`.
                      where :math:`N_1` is the batch_size. The data type can be int32 or int64.
    epsilon (float): The epsilon will be added to the numerator and denominator.
                     If both input and label are empty, it makes sure dice is 1.
                     Default: 0.00001
    name(str|None, optional): The default value is None.
                         Normally there is no need for user to set this property.
                         For more information, please refer to :ref:`api_guide_Name`

Returns:
    0-D Tensor, which shape is [], data type is the same as `input` .

Example:
    .. code-block:: python

        >>> import paddle
        >>> import paddle.nn.functional as F

        >>> x = paddle.randn((3,224,224,2))
        >>> label = paddle.randint(high=2, shape=(3,224,224,1))
        >>> predictions = F.softmax(x)
        >>> loss = F.dice_loss(input=predictions, label=label)
   z7The rank of input should be greater than or equal to 2.zAThe rank of input and label should be equal, but received input: z	, label: .   z6The last dimension of label should be 1, but received Nz3All dimensions should be equal except the last one.axis)dtypepaddlefloat32float64int32int64lenshapesqueezenn
functionalone_hotlistranger   r   )inputr!   epsilonname
reduce_diminsedice_denominator
dice_scores           Y/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/nn/functional/loss.py	dice_lossr?   1   s   ^ ;;6>>6>>::::;;6<<6666u{{q  A  u{{s5;;// 	"5;;/0	#ekk:J9K1	N/ ;;r?a 	B(	+ ;;su{{3B// =/ NN52$'EII  ((B@EeAs5;;/01J::em*5Dzz%9FJJ=  TAX!1!;<<J;;z""    c                   [        5       (       a  [        R                  " XU5      $ [        S
0 [	        5       D6n[        U SS/S5        [        USS/S5        UR                  U R                  S9nUR                  SU /U/S.SU/0SU0S	9  U$ )a  

**Negative Log Loss Layer**

This layer accepts input predictions and target label and returns the
negative log loss.

.. math::

    Out = -label * \log{(input + \epsilon)}
          - (1 - label) * \log{(1 - input + \epsilon)}

Args:
    input (Tensor):  A 2-D tensor with shape [N x 1], where N is the
                            batch size. This input is a probability computed
                            by the previous operator. Data type float32.
    label (Tensor):  The ground truth which is a 2-D tensor with
                            shape [N x 1], where N is the batch size.
                            Data type float32.
    epsilon (float, optional): A small number for numerical stability. Default 1e-4.
    name(str|None, optional): For detailed information, please refer to
        :ref:`api_guide_Name` . Usually name is no need to set and None by default.

Returns:
    Tensor, which shape is [N x 1], data type is float32.

Examples:
    .. code-block:: python

        >>> import paddle
        >>> import paddle.nn.functional as F

        >>> label = paddle.randn((10,1))
        >>> prob = paddle.randn((10,1))
        >>> cost = F.log_loss(input=prob, label=label)
log_lossr7   r+   r!   r)   )	PredictedLabelsLossr8   typeinputsoutputsattrs)rB   )	r   r   rB   r   localsr   "create_variable_for_type_inferencer)   	append_op)r7   r!   r8   r9   helperlosss         r>   rB   rB   |   s    T uW550vx0FUGi[*EUGi[*E445;;4GD
#W8$ '"	   Kr@   c           	        [        [        U R                  5      5      nUS:X  a  [        S5      e[        [        UR                  5      5      nUS-
  U:w  a  Xx:w  a  [        SU SU S35      eUS-
  U:X  a5  UR                  S   n	XR                  S   /n
[        R
                  " X5      n[        5       (       a*  [        R                  " U UUSUUU5      u  pU(       d  U$ X4$ UUUUS.n[        S0 [        5       D6nUR                  U R                  S
9nUR                  U R                  S
9nXS.nUR                  S	XS.UUS9  U(       a  X4$ U$ )a  

This operator implements the cross entropy loss function with softmax. This function
combines the calculation of the softmax operation and the cross entropy loss function
to provide a more numerically stable gradient.

Because this operator performs a softmax on logits internally, it expects
unscaled logits. This operator should not be used with the output of
softmax operator since that would produce incorrect results.

When the attribute :attr:`soft_label` is set :attr:`False`, this operators
expects mutually exclusive hard labels, each sample in a batch is in exactly
one class with a probability of 1.0. Each sample in the batch will have a
single label.

The equation is as follows:

1) Hard label (one-hot label, so every sample has exactly one class)

.. math::
    \\loss_j=-\text{logits}_{label_j} +\log\left(\sum_{i=0}^{K}\exp(\text{logits}_i)\right), j = 1,..., K

2) Soft label (each sample can have a distribution over all classes)

.. math::
    \\loss_j= -\sum_{i=0}^{K}\text{label}_i\left(\text{logits}_i - \log\left(\sum_{i=0}^{K}\exp(\text{logits}_i)\right)\right), j = 1,...,K

3) If :attr:`numeric_stable_mode` is :attr:`True`, softmax is calculated first by:

.. math::
    \\max_j&=\max_{i=0}^{K}{\text{logits}_i} \\
            log\_max\_sum_j &= \log\sum_{i=0}^{K}\exp(logits_i - max_j)\\
            softmax_j &= \exp(logits_j - max_j - {log\_max\_sum}_j)

and then cross entropy loss is calculated by softmax and label.

Args:
    logits (Tensor): A multi-dimension ``Tensor`` , and the data type is float32 or float64. The input tensor of unscaled log probabilities.
    label (Tensor): The ground truth  ``Tensor`` , data type is the same
        as the ``logits`` . If :attr:`soft_label` is set to :attr:`True`,
        Label is a ``Tensor``  in the same shape with :attr:`logits`.
        If :attr:`soft_label` is set to :attr:`True`, Label is a ``Tensor``
        in the same shape with :attr:`logits` expect shape in dimension :attr:`axis` as 1.
    soft_label (bool, optional): A flag to indicate whether to interpret the given
        labels as soft labels. Default False.
    ignore_index (int, optional): Specifies a target value that is ignored and does
                                  not contribute to the input gradient. Only valid
                                  if :attr:`soft_label` is set to :attr:`False`.
                                  Default: kIgnoreIndex(-100).
    numeric_stable_mode (bool, optional): A flag to indicate whether to use a more
                                          numerically stable algorithm. Only valid
                                          when :attr:`soft_label` is :attr:`False`
                                          and GPU is used. When :attr:`soft_label`
                                          is :attr:`True` or CPU is used, the
                                          algorithm is always numerically stable.
                                          Note that the speed may be slower when use
                                          stable algorithm. Default: True.
    return_softmax (bool, optional): A flag indicating whether to return the softmax
                                     along with the cross entropy loss. Default: False.
    axis (int, optional): The index of dimension to perform softmax calculations. It
                          should be in range :math:`[-1, rank - 1]`, while :math:`rank`
                          is the rank of input :attr:`logits`. Default: -1.

Returns:
    - If `return_softmax` is False, return the cross entropy loss as a ``Tensor``.
      The dtype is the same as the input ``logits``. The shape is consistent with ``logits`` except in dimension :attr:`axis` as 1.
    - If `return_softmax` is True, return a tuple of two ``Tensor``: the cross entropy loss and the softmax result.
      The dtype of the cross entropy loss is the same as the input ``logits``, and the shape is consistent with ``logits``
      except in dimension :attr:`axis` as 1. The dtype and shape of the softmax result are the same as the input ``logits``.


Examples:
    .. code-block:: python

        >>> import paddle
        >>> paddle.seed(2023)

        >>> logits = paddle.to_tensor([0.4, 0.6, 0.9])
        >>> label = paddle.randint(high=2, shape=[1], dtype="int64")

        >>> out = paddle.nn.functional.softmax_with_cross_entropy(logits=logits, label=label)
        >>> print(out)
        Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True,
                [1.15328646])
r   2The dimension of input should be larger than zero!r&   \Expected input_dims - 1 = label_dims or input_dims == label_dims             (got input_dims, label_dims)T)
soft_labelignore_indexnumeric_stable_moder(   softmax_with_cross_entropyrC   SoftmaxrF   LogitsLabelrG   rY   )r/   r5   r0   
ValueErrorr*   r   r   r   cross_entropy_with_softmaxr   rL   rM   r)   rN   )logitsr!   rV   rW   rX   return_softmaxr(   
input_dims
label_dims
batch_size	new_shapesoftmaxrP   rK   rO   rJ   s                   r>   base_softmax_with_cross_entropyri      s   | T&,,'(JQMNNT%++&'JA~#
(@'LZLC
 	
 A~#[[^
a1	u0 99
 K=  %(#6	
 FVXF;;&,,;O88v||8L%4-$5	 	 	
 = r@   c                   [        5       (       a6  U R                  S:X  a  [        S5      eUR                  S:X  a  [        S5      e[        U SSS/S5        [        USSS/S5        [        US	/ S
QS	5        SnUR                  S   n[
        R                  " X%S/S9n[
        R                  " USU/S9n[
        R                  " U[
        R                  " USS/S95      R                  S5      nU[
        R                  " USSS9-  n[
        R                  " [
        R                  " [
        R                  " U 5      S5      5      [
        R                  " [
        R                  " [
        R                  " U5      S5      5      -   nXd-  U-  n[
        R                  " XSSS9n[        XrSS9n[
        R                  " X(-  S5      n	[
        R                  " U	5      n
Xj-   $ )az  

Npair loss requires paired data. Npair loss has two parts: the first part is L2
regularizer on the embedding vector; the second part is cross entropy loss which
takes the similarity matrix of anchor and positive as logits.

For more information, please refer to:
`Improved Deep Metric Learning with Multi class N pair Loss Objective <http://www.nec-labs.com/uploads/images/Department-Images/MediaAnalytics/papers/nips16_npairmetriclearning.pdf>`_

Args:
  anchor(Tensor): embedding vector for the anchor image. shape=[batch_size, embedding_dims],
                    the data type is float32 or float64.
  positive(Tensor): embedding vector for the positive image. shape=[batch_size, embedding_dims],
                    the data type is float32 or float64.
  labels(Tensor): 1-D tensor. shape=[batch_size], the data type is float32 or float64 or int64.
  l2_reg(float, optional): L2 regularization term on embedding vector, default: 0.002.


Returns:
  A 0-D Tensor representing the npair loss, the data type is the same as anchor, the shape is [].

Examples:

    .. code-block:: python

        >>> import paddle
        >>> from typing import Literal
        >>> paddle.seed(2023)
        >>> dtype: Literal["float32"] = "float32"

        >>> anchor = paddle.rand(shape=(18, 6), dtype=dtype)
        >>> positive = paddle.rand(shape=(18, 6), dtype=dtype)
        >>> labels = paddle.rand(shape=(18,), dtype=dtype)

        >>> npair_loss = paddle.nn.functional.npair_loss(anchor, positive, labels, l2_reg = 0.002)
        >>> print(npair_loss)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
                2.94269347)

r   z,The dims of anchor should be greater than 0.z.The dims of positive should be greater than 0.anchorr+   r,   
npair_losspositivelabels)r+   r,   r.         ?r&   r0   )repeat_times)permT)r(   keepdimF)transpose_xtranspose_y)rb   r!   rV   )r	   sizer`   r   r0   r*   r   tileequal	transposeastyper   r   squarematmulri   )rk   rm   rn   l2_regBetarf   l2losssimilarity_matrix
softmax_cecross_entropycelosss              r>   rl   rl   U  s   V ;;!KLL==AMNN9i0, *y)4j 98 DaJ^^Fq/:F[[q*o>F\\&&"2"26A"GHOOF fjja>>F[[FMM&$91=>

6==*A.B F ]V#Fe 1 4J JJv2A6M[['F?r@   c                   [        5       (       a.  [        R                  " X5      n[        R                  " U5      nU$ [	        U SSS/S5        [	        USSS/S5        [        S0 [        5       D6nUR                  U R                  S9nUR                  SU /U/S.S	U/0S
9  UR                  U R                  S9nUR                  SSU/0S	U/0S
9  U$ )aA  

This op accepts input predictions and target label and returns the
squared error cost.

For predictions label, and target label, the equation is:

.. math::

    Out = (input - label)^2

Parameters:
    input (Tensor): Input tensor, the data type should be float32.
    label (Tensor): Label tensor, the data type should be float32.

Returns:
    Tensor, The tensor storing the element-wise squared error
    difference between input and label.

Examples:

    .. code-block:: python

        >>> import paddle
        >>> input = paddle.to_tensor([1.1, 1.9])
        >>> label = paddle.to_tensor([1.0, 2.0])
        >>> output = paddle.nn.functional.square_error_cost(input, label)
        >>> print(output)
        Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True,
                [0.01000000, 0.01000000])

r7   r+   r,   square_error_costr!   rC   elementwise_subXYOutrH   rI   rJ   r{   r   )r   )
r   r   subtractr{   r   r   rL   rM   r)   rN   )r7   r!   	minus_out
square_outrO   s        r>   r   r     s   B OOE1	]]9-
 7Y	24G	
 	!7Y	24G	
 =FH===EKK=P	"w/YK( 	 	
 >>++ ? 

 	)%ZL) 	 	

 r@   c                   [        S0 [        5       D6nUb  [        U5      S:  a  [        SU S35      e[	        5       (       a  [
        R                  " XXEU5      $ [        U SS/S5        [        USS/S5        U /U/S.nUb  Ub  U/US	'   U/US
'   UR                  SS9nUR                  SS9n	UR                  SUU/U	/S.SU0S9  X4$ )aR  
This op computes the edit distances, also called Levenshtein distance, between a batch of
hypothesis strings and their references. It measures how dissimilar two strings are by counting
the minimum number of operations to transform one string into another.
The operations include insertion, deletion, and substitution.

For example, given hypothesis string A = "kitten" and reference
B = "sitting", A will be transformed into B
at least after two substitutions and one insertion:

"kitten" -> "sitten" -> "sittin" -> "sitting"

So the edit distance between A and B is 3.

The input is a Tensor, the input_length and label_length should be supported.

The `batch_size` of labels should be same as `input`.

The output include the edit distance value between every pair of input and related label, and the number of sequence.
If Attr(normalized) is true,
the edit distance value will be divided by the length of label.

Parameters:
    input(Tensor): The input tensor, its rank should be equal to 2 and its data type should be int64.
    label(Tensor): The label tensor, its rank should be equal to 2 and its data type should be int64.
    normalized(bool, optional): Indicated whether to normalize the edit distance. Default: True.
    ignored_tokens(list|tuple|None, optional): Tokens that will be removed before calculating edit distance. Default: None.
    input_length(Tensor|None, optional): The length for each sequence in `input` if it's of Tensor type, it should have shape `(batch_size, )` and its data type should be int64.
    label_length(Tensor|None, optional): The length for each sequence in `label` if it's of Tensor type, it should have shape `(batch_size, )` and its data type should be int64.
    NOTE: To be avoid unexpected result, the value of every elements in input_length and label_length should be equal to the value of the second dimension of input and label. For example, The input: [[1,2,3,4],[5,6,7,8],[9,10,11,12]], the shape of input is [3,4] and the input_length should be [4,4,4]

Returns:
    Tuple:
        distance(Tensor): edit distance result, its data type is float32, and its shape is (batch_size, 1).
        sequence_num(Tensor): sequence number, its data type is float32, and its shape is (1,).

Examples:
    .. code-block:: python

        >>> import paddle
        >>> import paddle.nn.functional as F

        >>> input = paddle.to_tensor([[1,2,3],[4,5,6],[4,4,4],[1,1,1]], dtype='int64')
        >>> label = paddle.to_tensor([[1,3,4,1],[4,5,8,1],[7,7,7,1],[1,1,1,1]], dtype='int64')
        >>> input_len = paddle.to_tensor([3,3,3,3], dtype='int64')
        >>> label_len = paddle.to_tensor([4,4,4,4], dtype='int64')

        >>> distance, sequence_num = F.loss.edit_distance(input=input, label=label, input_length=input_len, label_length=label_len, normalized=False)
        >>> print(distance)
        Tensor(shape=[1], dtype=int64, place=Place(cpu), stop_gradient=True,
                [4])
        >>> print(sequence_num)
        Tensor(shape=[4, 1], dtype=float32, place=Place(cpu), stop_gradient=True,
                [[3.],
                 [2.],
                 [4.],
                 [1.]])

        >>> distance, sequence_num = F.loss.edit_distance(input=input, label=label, input_length=input_len, label_length=label_len, normalized=True)
        >>> print(distance)
        Tensor(shape=[1], dtype=int64, place=Place(cpu), stop_gradient=True,
                [4])
        >>> print(sequence_num)
        Tensor(shape=[4, 1], dtype=float32, place=Place(cpu), stop_gradient=True,
                [[0.75000000],
                 [0.50000000],
                 [1.        ],
                 [0.25000000]])

edit_distancer   z%Expected ignored_tokens is None (got rU   r7   r.   r!   )HypsRefs
HypsLength
RefsLengthrC   )r   SequenceNum
normalizedrG   )r   )
r   rL   r/   r`   r	   r   r   r   rM   rN   )
r7   r!   r   ignored_tokensinput_lengthlabel_lengthrO   this_inputsedit_distance_outsequence_nums
             r>   r   r     s   b 5FH5F !c.&9A&=3N3C1E
 	
 ##,j
 	
 UGgYHUGgYH!7UG4KL$<%1NL!%1NL! AAAP<<7<KL
*+\NKZ(	   **r@   c                   US;  a  [        SU S35      e[        5       (       al  [        R                  " X5      nUb  [        R                  " XR5      nUS:X  a  [        R
                  " U/ SS5      $ US:X  a  [        R                  " U5      $ U$ [        U S/ S	QS
5        [        US/ S	QS
5        Uc  US:X  a  UOSn[        S
US9nUR                  U R                  S9nUR                  SU /U/S.SU/0S9  UbT  [        U[        R                  R                  5      (       a   US:X  a  UOSn[        R                  " XRUS9nO[        S5      eUS:X  a  [        R
                  " XTS9$ US:X  a  [        R                   " XTS9$ U$ )aR
  
Measure the binary_cross_entropy loss between input predictions ``input``
and target labels ``label`` . The binary_cross_entropy loss can be described as:

If :attr:`weight` is set, the loss is:

.. math::
    Out = -1 * weight * (label * log(input) + (1 - label) * log(1 - input))

If :attr:`weight` is None, the loss is:

.. math::
    Out = -1 * (label * log(input) + (1 - label) * log(1 - input))

If :attr:`reduction` set to ``'none'``, the interface will return the original loss `Out`.

If :attr:`reduction` set to ``'mean'``, the reduced mean loss is:

.. math::
    Out = MEAN(Out)

If :attr:`reduction` set to ``'sum'``, the reduced sum loss is:

.. math::
    Out = SUM(Out)

Note that the input predictions ``input`` always be the output of sigmoid, and the target labels ``label``
should be numbers between 0 and 1.

Parameters:
    input (Tensor): The input predications tensor. 2-D tensor with shape: [N, *],
        N is batch_size, `*` means number of additional dimensions. The ``input``
        should always be the output of sigmoid.  Available dtype is float16, float32, float64.
    label (Tensor): The target labels tensor. 2-D tensor with the same shape as
        ``input``. The target labels which values should be numbers between 0 and 1.
        Available dtype is float16, float32, float64.
    weight (Tensor, optional): A manual rescaling weight given to the loss of each
        batch element. If given, has to be a Tensor of size nbatch and the data type
        is float32, float64. Default is ``'None'``.
    reduction (str, optional): Indicate how to average the loss by batch_size,
        the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
        If :attr:`reduction` is ``'none'``, the unreduced loss is returned;
        If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
        If :attr:`reduction` is ``'sum'``, the summed loss is returned.
        Default is ``'mean'``.
    name (str|None, optional): Name for the operation (optional, default is None).
        For more information, please refer to :ref:`api_guide_Name`.


Returns:
    Tensor. If ``reduction`` is ``'none'``, the shape of output is
        same as ``input`` , else the shape of output is scalar.

Examples:
    .. code-block:: python

        >>> import paddle

        >>> input = paddle.to_tensor([0.5, 0.6, 0.7], 'float32')
        >>> label = paddle.to_tensor([1.0, 0.0, 1.0], 'float32')
        >>> output = paddle.nn.functional.binary_cross_entropy(input, label)
        >>> print(output)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
                0.65537095)

r   r   r   zaThe value of 'reduction' in binary_cross_entropy should be 'sum', 'mean' or 'none', but received , which is not allowed.Nr   Fr   r7   float16r+   r,   binary_cross_entropyr!   r   r9   rC   bce_lossr   r^   r   r   z5The weight is not a Tensor, please convert to Tensor.)r`   r   r   r   multiplyr   mean_allr   r   rM   r)   rN   
isinstancer*   staticr   r   )	r7   r!   weight	reductionr9   outsub_namerO   weight_names	            r>   r   r   [  s   R //..7[8OQ
 	

 ooe+//#.C::c2tU33& ??3''J -"		
 	!-"		
 ">i6.A4t3(C77ekk7JW SEN 	 	
 &&--"8"899&/6&9dtoocD K  ::c--& ;;s..Jr@   c           	     j   US;  a  [        SU S35      e[        5       (       Ga9  [        5       (       aL  [        U S[        R
                  R                  S5        [        US[        R
                  R                  S5        [        R                  " S/SU R                  [        5       5      nUb@  [        R                  " [        R                  " U[        R                  " XF5      5      U5      n[        R                  " XUS
S5      nUb  [        R                  " Xr5      nUS:X  a  [        R                  " U/ S	S
5      $ US:X  a  [        R                   " U5      $ U$ [#        U SSS/S5        [#        USSS/S5        S	nUS:X  a  Uc  Uc  Un[%        S0 ['        5       D6n	U	R)                  U R                  S9n[        R                  " S/SU R                  S9nUbP  [#        USSS/S5        [        R                  " [        R                  " U[        R                  " XF5      5      U5      nU	R+                  SXUS.[,        S
S.SU0S9  Ub/  [#        USSS/S5        US:X  a  UOS	n
[        R                  " XrU
S9nUS:X  a  [        R                  " XuS9$ US:X  a  [        R.                  " XuS9$ U$ )a  
Combine the sigmoid layer and the :ref:`api_paddle_nn_BCELoss` layer.

This measures the element-wise probability error in classification tasks
in which each class is independent.
This can be thought of as predicting labels for a data-point, where labels
are not mutually exclusive. For example, a news article can be about
politics, technology or sports at the same time or none of these.

Firstly, calculate loss function as follows:

.. math::
       Out = -Labels * \log(\sigma(Logit)) - (1 - Labels) * \log(1 - \sigma(Logit))

We know that :math:`\sigma(Logit) = \frac{1}{1 + e^{-Logit}}`. By substituting this we get:

.. math::
       Out = Logit - Logit * Labels + \log(1 + e^{-Logit})

For stability and to prevent overflow of :math:`e^{-Logit}` when Logit < 0,
we reformulate the loss as follows:

.. math::
       Out = \max(Logit, 0) - Logit * Labels + \log(1 + e^{-\|Logit\|})

Then, if ``weight`` or ``pos_weight`` is not None, then multiply the
weight tensor on the loss `Out`. The ``weight`` tensor will attach different
weight on every items in the batch. The ``pos_weight`` will attach different
weight on the positive label of each class.

Finally, apply reduce operation on the loss.
If :attr:`reduction` set to ``'none'``, will return the original loss `Out`.
If :attr:`reduction` set to ``'mean'``, the reduced mean loss is :math:`Out = MEAN(Out)`.
If :attr:`reduction` set to ``'sum'``, the reduced sum loss is :math:`Out = SUM(Out)`.

Note that the target labels ``label`` should be numbers between 0 and 1.

Args:
    logit (Tensor): The input predications tensor. 2-D tensor with shape: [N, *],
        N is batch_size, `*` means number of additional dimensions. The ``logit``
        is usually the output of Linear layer. Available dtype is float32, float64.
    label (Tensor): The target labels tensor. 2-D tensor with the same shape as
        ``logit``. The target labels which values should be numbers between 0 and 1.
        Available dtype is float32, float64.
    weight (Tensor, optional): A manual rescaling weight given to the loss of each
        batch element. If given, it has to be a 1D Tensor whose size is `[N, ]`,
        The data type is float32, float64. Default is ``'None'``.
    reduction (str, optional): Indicate how to average the loss by batch_size,
        the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
        If :attr:`reduction` is ``'none'``, the unreduced loss is returned;
        If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
        If :attr:`reduction` is ``'sum'``, the summed loss is returned.
        Default is ``'mean'``.
    pos_weight (Tensor, optional): A weight of positive examples. Must be a vector
        with length equal to the number of classes. The data type is float32, float64.
        Default is ``'None'``.
    name (str, optional): Name for the operation (optional, default is None).
        For more information, please refer to :ref:`api_guide_Name`.

Returns:
    Tensor. If ``reduction`` is ``'none'``, the shape of output is
        same as ``logit`` , else the shape of output is scalar.

Examples:

    .. code-block:: python

        >>> import paddle

        >>> logit = paddle.to_tensor([5.0, 1.0, 3.0])
        >>> label = paddle.to_tensor([1.0, 0.0, 1.0])
        >>> output = paddle.nn.functional.binary_cross_entropy_with_logits(logit, label)
        >>> print(output)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
                0.45618808)

r   zmThe value of 'reduction' in binary_cross_entropy_with_logits should be 'sum', 'mean' or 'none', but received r   logit binary_cross_entropy_with_logitsr!   r&         ?NFr    r   r   r+   r,   r   !sigmoid_cross_entropy_with_logitsrC   r0   
fill_valuer)   
pos_weight)r   r^   r   )rW   	normalizer   )rH   rI   rK   rJ   r   r   )r   )r`   r   r   r   r*   pirValuer   fullr)   r   addr   r   r   r   r   r   r   rL   rM   rN   kIgnoreIndexr   )r   r!   r   r   r   r9   oner   sigmoid_namerO   r   s              r>   r   r     s   j //??HkI`b
 	

 ==

  2	 

  2	 kkCKK#%	
 !vz'GH#J 66*eT
 //#.C::c2tU33& ??3''J 	".		
 	!	".		
 :#5&.LMFHM77ekk7Jkk5;;G!$I&2	  vz'GH#J 	4jI#/eDCL	 	 	
 $I&2	 #,v"5$4K//#K@C::c--& ;;s..
r@   c	                   US:  a  [        SU S35      e[        5       (       a$  [        R                  " U UUUUUUUU5	      u  n	  n
U	$ [	        U SSS/S5        [	        USS	/S5        [	        US
SS/S5        Ub  [	        USSS/S5        Ub  [	        USS	/S5        Ub  [	        USS	/S5        [        5       (       a$  [        R                  " U UUUUUUUU5	      u  n	  n
U	$ UUS.nU UUUUUS.n[        S0 [        5       D6nUR                  U R                  5      n	UR                  U R                  5      nXUS.nUR                  SUUUS9  U	$ )aI  
The hierarchical sigmoid organizes the classes into a complete binary tree to reduce the computational complexity
and speed up the model training, especially the training of language model.

Each leaf node of the complete binary tree represents a class(word) and each non-leaf node acts as a binary classifier.
For each class(word), there's a unique path from root to itself, hsigmoid calculate the cost for each non-leaf node on
the path, and sum them to get a total cost.

Comparing to softmax, hsigmoid can reduce the computational complexity from :math:`O(N)` to :math:`O(logN)`, where :math:`N`
represents the number of classes or the size of word dict.

The API supports default tree and custom tree. For the default tree, you can refer to `Hierarchical Probabilistic Neural
Network Language Model <http://www.iro.umontreal.ca/~lisa/pointeurs/hierarchical-nnlm-aistats05.pdf>`_.

For the custom tree, you need to set :attr:`is_custom` to True, and do the following steps (take the language model as an example):

1. Using a custom word dict to build a binary tree, each leaf node should be an word in the word dict.
2. Creating a dict map word_id -> path that from the word to the root node, we call it path_table.
3. Creating a dict map word_id -> code of path that from the word to the root node, we call it path_code.
   Code means the label of each binary classifier, 1 indicate true, 0 indicate false.
4. Now, each word should has its path and code along the path, you can pass a batch of path and code related
   to the same batch of inputs.

Parameters:
    input (Tensor): A tensor with the shape [N, D], where N is the size of mini-batch,
        and D is the feature size. Its data type supports float32 or float64.
    label (Tensor): A tensor contains the labels of training data. Its shape is [N, 1]
        and data type is int64.
    num_classes (int): The number of classes or the size of word dict, must be greater than 2.
        If the default tree is used (path_code and path_table is None are None), `num_classes`
        should not be None. If the custom tree is used (path_code and path_table is None are not None),
        `num_classes` should be the number of non-leaf nodes, which indicates the num of
        classes using by the binary classifier.
    weight (Tensor): A tensor with shape (num_classes - 1, D), with the same data type as `input`.
    bias (Tensor, optional): A tensor with shape (num_classes - 1, 1), with the same data type as `input`.
        If `bias` is None, no bias will be add. Default is None.
    path_table (Tensor, optional): A tensor that stores each batch of samples' path from leaf to root
        node, its shape is [N, L] and data type is int64, where L is the length of path. For each sample i,
        path_table[i] is a np.array like structure and each element in this array is the indexes in parent
        nodes' weight matrix. If `path_table` and `path_code` are None, the default tree will be used.
        Default is None.
    path_code (Tensor, optional): A tensor that stores each batch of samples' code of path from leaf
        to root node, its shape is [N, L] and data type is int64, which is the same as :attr:`path_table`.
        Each code of path is consisted with the code of nodes from leaf to root node. If `path_table` and
        `path_code` are None, the default tree will be used. Default is None.
    is_sparse (bool, optional): Whether use sparse updating instead of dense updating. If `is_sparse` is True,
        the gradient of `weight` and `input` will be sparse. Default is False.
    name (str|None, optional): Name for the operation (optional, default is None).
        For more information, please refer to :ref:`api_guide_Name`.

Returns:
    A tensor with the cost of hierarchical sigmoid, its shape is [N, 1] and data type is the same as `input`.

Examples:
    .. code-block:: python

        >>> import paddle
        >>> import paddle.nn.functional as F

        >>> paddle.set_device('cpu')
        >>> paddle.seed(2023)

        >>> input = paddle.uniform([4, 3])
        >>> print(input)
        Tensor(shape=[4, 3], dtype=float32, place=Place(cpu), stop_gradient=True,
                [[ 0.73167229,  0.04029441, -0.48078126],
                 [ 0.81050646, -0.15199822, -0.18717426],
                 [ 0.94041789,  0.48874724,  0.03570259],
                 [ 0.46585739,  0.95573163, -0.91368192]])
        >>> label = paddle.to_tensor([0, 1, 4, 5])
        >>> num_classes = 5
        >>> weight = paddle.uniform([num_classes - 1, 3])
        >>> print(weight)
        Tensor(shape=[4, 3], dtype=float32, place=Place(cpu), stop_gradient=True,
                [[-0.14721161,  0.43916738, -0.58377075],
                 [-0.60536981, -0.23151302, -0.70793629],
                 [-0.54572451, -0.10784978, -0.56684279],
                 [ 0.35370791, -0.07079649,  0.84765708]])
        >>> out = F.hsigmoid_loss(input, label, num_classes, weight)
        >>> print(out)
        Tensor(shape=[4, 1], dtype=float32, place=Place(cpu), stop_gradient=True,
                [[2.23681736],
                 [1.97140026],
                 [1.66425037],
                 [2.54727197]])

r#   zExpected num_classes >= 2 (got rU   r7   r+   r,   hsigmoid_lossr!   r.   r   bias
path_table	path_code)num_classes	is_sparse)r   WBias	PathTablePathCoder^   )r   PreOutW_Outhierarchical_sigmoidrG   )r   )r`   r	   r   r   r   r   r   rL   rM   r)   rN   )r7   r!   r   r   r   r   r   r   r9   r   _rK   rI   rO   pre_outrJ   s                   r>   r   r     s   D Q:;-qIJJ((

	Q 
wI. UGgYH9i0/  &9i0/	
  wi	
  {WI	
 }}((

	Q 
 '"
 #!
 9977D;;EKKH6B'	 	 	
 
r@   c                   [        5       (       a  [        R                  " XU5      nO[        U S/ SQS5        [        US/ SQS5        [	        S0 [        5       D6nUR                  UR                  5       S9nUR                  UR                  5       S9nUR                  SXS.XhS.S	U0S
9  U(       d  Xc-  nUS;  a  [        SU S35      eUS:X  a  U$ US:X  a  [        R                  " U5      $ US:X  a  [        R                  " U5      $ g)ah	  
Calculate smooth_l1_loss. Creates a criterion that uses a squared
term if the absolute element-wise error falls below 1 and an L1 term otherwise.
In some cases it can prevent exploding gradients and it is more robust and less
sensitivity to outliers. Also known as the Huber loss:

.. math::

    loss(x,y) = \frac{1}{n}\sum_{i}z_i


where :math:`z_i` is given by:

.. math::

    \mathop{z_i} = \left\{\begin{array}{rcl}
            0.5(x_i - y_i)^2 & & {if |x_i - y_i| < \delta} \\
            \delta * |x_i - y_i| - 0.5 * \delta^2 & & {otherwise}
        \end{array} \right.

Parameters:
    input (Tensor): Input tensor, the data type is float32 or float64. Shape is
        (N, C), where C is number of classes, and if shape is more than 2D, this
        is (N, C, D1, D2,..., Dk), k >= 1.
    label (Tensor): Label tensor, the data type is float32 or float64. The shape of label
        is the same as the shape of input.
    reduction (str, optional): Indicate how to average the loss by batch_size,
        the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
        If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
        If :attr:`reduction` is ``'sum'``, the reduced sum loss is returned.
        If :attr:`reduction` is ``'none'``, the unreduced loss is returned.
        Default is ``'mean'``.
    delta (float, optional): Specifies the hyperparameter :math:`\delta` to be used.
        The value determines how large the errors need to be to use L1. Errors
        smaller than delta are minimized with L2. Parameter is ignored for
        negative/zero values. Default = 1.0
    is_huber (bool, optional): If True, use the Huber loss, otherwise use a modified version where the Huber loss is divided by delta. Default is True.
    name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None.

Returns:
    Tensor, The tensor variable storing the smooth_l1_loss of input and label.

Examples:
    .. code-block:: python

        >>> import paddle
        >>> paddle.seed(2023)

        >>> input = paddle.rand([3, 3]).astype('float32')
        >>> label = paddle.rand([3, 3]).astype('float32')
        >>> output = paddle.nn.functional.smooth_l1_loss(input, label)
        >>> print(output)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
                0.08307374)

r7   )r   r+   r,   uint16smooth_l1_lossr!   
huber_lossrC   r   )r   ResidualdeltarG   r   z[The value of 'reduction' in smooth_l1_loss should be 'sum', 'mean' or 'none', but received r   r   r   r   N)r   )r   r   r   r   r   rL   rM   input_dtyperN   r`   r*   r   r   )	r7   r!   r   r   is_huberr9   r   rO   residuals	            r>   r   r   L  sA   B e4 7		
 	!7		
 6VX6<<$$& = 
 77$$& 8 
 	+6E"	 	 	
 k//%%.K/FH
 	
 F
	f	{{3	e	zz# 
r@   c                $   US;  a  [        SU S35      e[        5       (       a  [        R                  " X5      n[        R                  " Xb5      nUS:w  a6  [
        R                  " U/UR                  S9n[        R                  " Xc5      n[        R                  " U5      nUS:X  a  [        R                  " U/ SS5      $ US	:X  a  [        R                  " U5      $ U$ [        S0 [        5       D6n[        U S
SS/S5        [        USSS/S5        [        USSS/S5        [
        R                  " X5      n[
        R                  " U5      n[
        R                  " X5      nUS:w  aY  UR                   R#                  UR                  S9n	[
        R$                  " S/X6R                  S9n	[
        R                  " Xi5      nUR'                  U R                  5      n
US:X  a  UR)                  SSU0SU
0S9  U
$ US:X  aH  [
        R*                  R,                  R                  U5      nS/SSS.nUR)                  SSU0SU
0US9  U
$ US	:X  aA  [
        R*                  R,                  R                  U5      nUR)                  S	SU0SU
00 S9  U
$ g)a  

Calculate the margin rank loss between the input, other and label, use the math function as follows.

.. math::
    margin\_rank\_loss = max(0, -label * (input - other) + margin)

If :attr:`reduction` set to ``'mean'``, the reduced mean loss is:

.. math::
    Out = MEAN(margin\_rank\_loss)

If :attr:`reduction` set to ``'sum'``, the reduced sum loss is:

.. math::
    Out = SUM(margin\_rank\_loss)

If :attr:`reduction` set to ``'none'``, just return the origin ``margin_rank_loss``.

Parameters:
    input(Tensor): the first input tensor, it's data type should be float32, float64.
    other(Tensor): the second input tensor, it's data type should be float32, float64.
    label(Tensor): the label value corresponding to input, it's data type should be float32, float64.
    margin (float, optional): The margin value to add, default value is 0;
    reduction (str, optional): Indicate the reduction to apply to the loss, the candidates are ``'none'``, ``'mean'``, ``'sum'``.If :attr:`reduction` is ``'none'``, the unreduced loss is returned; If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned. If :attr:`reduction` is ``'sum'``, the reduced sum loss is returned. Default is ``'mean'``.
    name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.

Returns:
    Tensor, if :attr:`reduction` is ``'mean'`` or ``'sum'``, the out shape is :math:`[]`, otherwise the shape is the same as `input` .The same dtype as input tensor.

Examples:

    .. code-block:: python

        >>> import paddle

        >>> input = paddle.to_tensor([[1, 2], [3, 4]], dtype='float32')
        >>> other = paddle.to_tensor([[2, 1], [2, 4]], dtype='float32')
        >>> label = paddle.to_tensor([[1, -1], [-1, -1]], dtype='float32')
        >>> loss = paddle.nn.functional.margin_ranking_loss(input, other, label)
        >>> print(loss)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
                0.75000000)

r   z^The value of 'reduction' in MarginRankingLoss should be 'sum', 'mean' or 'none', but received r           rC   r   NFr   r7   r+   r,   margin_rank_lossotherr!   r&   r   r   relur   r   r   r   T)dimkeep_dim
reduce_all
reduce_sumrG   )margin_ranking_loss)r`   r   r   r   r   r*   	to_tensorr)   r   r   r   r   r   rL   r   negblock
create_varr   rM   rN   r2   r3   )r7   r   r!   marginr   r9   r   rO   	neg_label
margin_var
result_outrK   s               r>   r   r     s   j //!{"9;
 	
 ooe+ooc)S=%%vhcii@F**S)Ckk#::c2tU33& ??3''
?fh? 7Y	24F	
 	!7Y	24F	
 	!7Y	24F	
 ooe+JJu%	ooi-S=--CII->JcfIIJ **S-C>>u{{K
S#J
8K   %))&&++C0CCU$GE!Sz
+	   & ))&&++C0CSz
+	    !r@   c                   US;  a  [        SU S35      e[        5       (       ag  [        R                  " [        R                  " X5      5      nUS:X  a  [        R
                  " U5      $ US:X  a  [        R                  " U/ SS5      $ U$ [        U S/ S	QS
5        [        US/ S	QS
5        US:X  a<  [        R                  " [        R                  " XS95      n[        R                  " XCS9$ US:X  a<  [        R                  " [        R                  " XS95      n[        R                  " XCS9$ [        R                  " [        R                  " XUS95      $ )aG	  

Computes the L1 Loss of Tensor ``input`` and ``label`` as follows.

If `reduction` set to ``'none'``, the loss is:

.. math::
    Out = \lvert input - label \rvert

If `reduction` set to ``'mean'``, the loss is:

.. math::
    Out = MEAN(\lvert input - label \rvert)

If `reduction` set to ``'sum'``, the loss is:

.. math::
    Out = SUM(\lvert input - label \rvert)


Parameters:
    input (Tensor): The input tensor. The shapes is [N, `*`], where N is batch size and `*` means any number of additional dimensions. It's data type should be float32, float64, int32, int64.
    label (Tensor): label. The shapes is [N, `*`], same shape as ``input`` . It's data type should be float32, float64, int32, int64.
    reduction (str, optional): Indicate the reduction to apply to the loss,
        the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
        If `reduction` is ``'none'``, the unreduced loss is returned;
        If `reduction` is ``'mean'``, the reduced mean loss is returned.
        If `reduction` is ``'sum'``, the reduced sum loss is returned.
        Default is ``'mean'``.
    name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.

Returns:
    Tensor, the L1 Loss of Tensor ``input`` and ``label``.
    If `reduction` is ``'none'``, the shape of output loss is :math:`[N, *]`, the same as ``input`` .
    If `reduction` is ``'mean'`` or ``'sum'``, the shape of output loss is [].

Examples:
    .. code-block:: python

        >>> import paddle

        >>> input = paddle.to_tensor([[1.5, 0.8], [0.2, 1.3]])
        >>> label = paddle.to_tensor([[1.7, 1], [0.4, 0.5]])

        >>> l1_loss = paddle.nn.functional.l1_loss(input, label)
        >>> print(l1_loss)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
                0.34999999)

        >>> l1_loss = paddle.nn.functional.l1_loss(input, label, reduction='none')
        >>> print(l1_loss)
        Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True,
                [[0.20000005, 0.19999999],
                 [0.20000000, 0.79999995]])

        >>> l1_loss = paddle.nn.functional.l1_loss(input, label, reduction='sum')
        >>> print(l1_loss)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
                1.39999998)

r   zSThe value of 'reduction' in L1Loss should be 'sum', 'mean' or 'none', but received r   r   r   NFr7   )r+   r,   r-   r.   r   l1_lossr!   )xyr   )r   r   r9   )
r`   r   r   absr   r   r   r   r*   r   )r7   r!   r   r9   	unreduceds        r>   r   r   3  s+   F //!{"9;
 	

 JJvu<=	??9--%::iT599 ?		
 	!?		
 

6??U#DEI::i33& 

6??U#DEI;;y44::fooTJKKr@   c                j   US;  a  [        SU S35      e[        U R                  5      n[        U5      n[        UR                  5      n[        U5      n	US-
  U	:w  a  Xy:w  a  [        SU SU	 S35      eUS:  a  [        S	U S35      eUS   S:  a  [        S
US    S35      eUS   n
US   n[	        5       (       a  US:w  aA  US:w  a;  [
        R                  " X
USS/5      n [
        R                  " XSS/5      nU
/USS Qn[
        R                  " XX#U5      u  pUS:w  a#  US:w  a  US:X  a  [
        R                  " UW5      nU$ [        S0 [        5       D6nUS:w  a'  US:w  a!  [        X
USS/S9n [        XSS/S9nU
/USS Qn[        U SSS/S5        [        USS/S5        XS.nXCS.nUb  [        U[        5      (       a  UUS'   UR                  U R                  S9nUR                  U R                  S9nXS.nUR                  SUUUS9  US:w  a  US:w  a  US:X  a
  [        UWS9nU$ )a  
This api returns negative log likelihood.
See more detail in :ref:`NLLLoss <api_paddle_nn_NLLLoss>` .


Parameters:
     input (Tensor): Input tensor, the shape is :math:`[N, C]`, `C` is the number of classes.
         But in K-dimension situation, the shape is :math:`[N, C, d_1, d_2, ..., d_K]`.
         The data type is float32, float64.
     label (Tensor): Label tensor, the shape is :math:`[N,]` or :math:`[N, d_1, d_2, ..., d_K]`.
         The data type is int64.
     weight (Tensor, optional): Weight tensor, a manual rescaling weight given
         to each class. If given, it has to be a 1D Tensor whose size is `[C, ]`. Otherwise,
         it treated as if having all ones. the data type is
         float32, float64, Default is ``'None'``.
     ignore_index (int, optional): Specifies a target value that is ignored
         and does not contribute to the input gradient. Default is -100.
     reduction (str, optional): Indicate how to average the loss,
         the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
         If `reduction` is ``'mean'``, the reduced mean loss is returned;
         if `reduction` is ``'sum'``, the reduced sum loss is returned;
         if `reduction` is ``'none'``, no reduction will be applied.
         Default is ``'mean'``.
     name (str|None, optional): Name for the operation (optional, default is None).
         For more information, please refer to :ref:`api_guide_Name`.

Returns:
     `Tensor`, the value of negative log likelihood loss.

Examples:
    .. code-block:: python

        >>> import paddle
        >>> from paddle.nn.functional import nll_loss
        >>> log_softmax = paddle.nn.LogSoftmax(axis=1)

        >>> input = paddle.to_tensor([[0.88103855, 0.9908683 , 0.6226845 ],
        ...     [0.53331435, 0.07999352, 0.8549948 ],
        ...     [0.25879037, 0.39530203, 0.698465  ],
        ...     [0.73427284, 0.63575995, 0.18827209],
        ...     [0.05689114, 0.0862954 , 0.6325046 ]], "float32")
        >>> log_out = log_softmax(input)
        >>> label = paddle.to_tensor([0, 2, 1, 1, 0], "int64")
        >>> result = nll_loss(log_out, label)
        >>> print(result)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               1.07202101)

r   zUThe value of 'reduction' in nll_loss should be 'sum', 'mean' or 'none', but received r   r&   rS   rT   rU   r#   z#Expected 2 or more dimensions (got z+Expected 1 or more classes (got num classesr      r%   Nr   nll_lossrp   r7   r+   r,   r!   r.   r   )r   rW   WeightrC   )r   Total_weightrG   )r   )r`   r5   r0   r/   r   r   r   r   r   rL   r   r   r   rM   r)   rN   )r7   r!   r   rW   r   r9   input_shaperd   label_shapere   nc	out_shaper   total_weightrO   rI   rK   rJ   s                      r>   r   r     s   r //$$-;.EG
 	

 u{{#K[!Ju{{#K[!JA~#
(@'LZLC
 	

 A~>zl!LMM1~9+a.9IK
 	
 	AAAA?zQNN5aB-8ENN5a*5E-[_-I"OO&	
 ?zQ93F..i0C
4684?zQEQ27EEQ4E-[_-I 7Y	2J	
 	!'JG-'F&(++#)x 77ekk7J@@++ A 
 <FG5 	 	
 ?zQ93F#Y/C
r@   c                   US::  a  [        SUS S35      eUS;  a  [        SU S35      e[        U S/ S	QS
5        [        US/ S	QS
5        U R                  UR                  :X  d  [        S5      eSnU(       a  [        R                  " U 5      X-  -
  nOX[        R
                  " X-   5      -  -
  nU(       a|  U[        R
                  " U5      -  U-
  S[        R
                  " S[        R                  -  U-  5      -  -   nU[        R                  " US:  U[        R                  " U5      5      -  nUS:X  a  [        R                  " U5      nU$ US:X  a  [        R                  " U5      nU$ )a
  Poisson negative log likelihood loss.
See more detail in :ref:`PoissonNLLLoss <api_paddle_nn_PoissonNLLLoss>` .

Parameters:
     input (Tensor):
        Input tensor, expectation of underlying Poisson distribution.
        The shape of input tensor should be `(N, *)` or `(*)` where `(*)` denotes any number of extra dimensions.
        It's data type should be float16, bfloat16, float32, float64.
     label (Tensor):
        Label tensor, random sampled from Poisson distribution :math:`label \sim \text{Poisson}(input)`.
        The shape of input tensor should be `(N, *)` or `(*)`, same shape as the input tensor.
        It's data type should be float16, bfloat16, float32, float64.
     log_input (bool, optional):
        Whether to the treat input tensor as log input.
        If ``True`` the loss is computed as, :math:`\exp(\text{input}) - \text{label} * \text{input}` .
        If ``False`` then loss is :math:`\text{input} - \text{label} * \log(\text{input}+\text{epsilon})` .
        Default: ``True``.
     full (bool, optional):
        Whether to compute full loss.
        If ``True``, the Stirling approximation term is added.
        If ``False``, the Stirling approximation is dropped.
        Default: ``False``.
     epsilon (float, optional):
        A small value to avoid evaluation of :math:`\log(0)` when `log_input`\ =\ ``False``. ``epsilon > 0``.
        Default: 1e-8.
     reduction (str, optional):
        Indicate how to reduce the loss, the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
        If `reduction` is ``'mean'``, the reduced mean loss is returned;
        if `reduction` is ``'sum'``, the reduced sum loss is returned;
        if `reduction` is ``'none'``, no reduction will be applied.
        Default is ``'mean'``.
     name (str|None, optional):
        Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.

Examples:
    .. code-block:: python

        >>> import paddle
        >>> import paddle.nn.functional as F
        >>> paddle.seed(2023)

        >>> input = paddle.randn([5, 2], dtype=paddle.float32)
        >>> label = paddle.randn([5, 2], dtype=paddle.float32)
        >>> loss = F.poisson_nll_loss(input, label, log_input=True, reduction='none')
        >>> print(loss)
        Tensor(shape=[5, 2], dtype=float32, place=Place(cpu), stop_gradient=True,
               [[ 1.09998012,  3.68829036],
                [ 1.95291090,  0.69603068],
                [-0.39289063, -2.03713036],
                [ 4.52518702,  1.28625548],
                [ 3.94454789,  0.53521496]])
        >>> loss = F.poisson_nll_loss(input, label, reduction='mean')
        >>> print(loss)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               1.52983975)

r   zLThe value of `epsilon` in poisson_nll_loss should be positive, but received fz, which is not allowedr   z]The value of 'reduction' in poisson_nll_loss should be 'sum', 'mean' or 'none', but received r   r7   )r   r   r+   r,   poisson_nll_lossr!   )input's shape must equal to label's shape      ?r#   r&   r   r   )r`   r   r0   r*   explogmathpiwhere
zeros_liker   r   )	r7   r!   	log_inputr   r8   r   r9   loss_outstirling_approxs	            r>   r   r     s   F !|Z[bcdZee{|
 	
 //!{"9;
 	

 3	 3	 KK5;;&DEEH::e$u}46::eo#>>>FJJu%%FJJq477{U2334 	
 	FLLAIo.
 	

 F;;x( O 
e	::h'Or@   c                "   [         R                  R                  U R                  5      S:X  aE  [         R                  R                  UR                  5      S:X  a  [        R
                  " U S5      n Oq[         R                  R                  U R                  5      S:X  aD  [         R                  R                  UR                  5      S:X  a  [        R
                  " US5      n[        5       (       a  [        R                  " XSU5      nUS:X  a  [        R                  " U5      nU$ US:X  a  [        R                  " U5      nU$ US:X  aA  [        U R                  5      S:  a(  U R                  S   n[        R                  " U5      U-  nU$ [        S0 [        5       D6n[        U S	SS/S5        [        US
SS/S5        [         R                  R!                  US["        S5        UR%                  U R                  S9nUR'                  SXS.SU0SUS.S9  US:X  a  [        R                  " U5      nU$ US:X  a  [        R                  " U5      nU$ US:X  a2  [        R                  " U 5      S   n[        R                  " U5      U-  nU$ )a  
Calculate the Kullback-Leibler divergence loss
between Input(X) and Input(Target). Notes that Input(X) is the
log-probability and Input(Target) is the probability.

KL divergence loss is calculated as follows:

If `log_target` is False:

$$l(x, y) = y * (\log(y) - x)$$

If `log_target` is True:

$$l(x, y) = \exp(y) * (y - x)$$

Here :math:`x` is input and :math:`y` is label.

If `reduction` is ``'none'``, the output loss is the same shape as the input, and the loss at each point is calculated separately. There is no reduction to the result.

If `reduction` is ``'mean'``, the output loss is the shape of [], and the output is the average of all losses.

If `reduction` is ``'sum'``, the output loss is the shape of [], and the output is the sum of all losses.

If `reduction` is ``'batchmean'``, the output loss is the shape of [N], N is the batch size, and the output is the sum of all losses divided by the batch size.

Args:
    input (Tensor): The input tensor. The shapes is [N, *], where N is batch size and `*` means
        any number of additional dimensions. It's data type should be float32, float64.
    label (Tensor): label. The shapes is [N, *], same shape as ``input`` . It's data type should be float32, float64.
    reduction (str, optional): Indicate how to average the loss,
        the candidates are ``'none'`` | ``'batchmean'`` | ``'mean'`` | ``'sum'``.
        If `reduction` is ``'mean'``, the reduced mean loss is returned;
        If `reduction` is ``'batchmean'``, the sum loss divided by batch size is returned;
        if `reduction` is ``'sum'``, the reduced sum loss is returned;
        if `reduction` is ``'none'``, no reduction will be applied.
        Default is ``'mean'``.
    log_target (bool, optional): Indicate whether `label` is passed in log space. Default is False.
    name(str, optional): Name for the operation (optional, default is None). For more information,
        please refer to :ref:`api_guide_Name`.

Returns:
    Tensor: The KL divergence loss. The data type is same as input tensor

Examples:
    .. code-block:: pycon

        >>> import paddle
        >>> import paddle.nn.functional as F
        >>> paddle.seed(2023)

        >>> shape = (5, 20)

        >>> # input(x) should be a distribution in the log space
        >>> x = F.log_softmax(paddle.randn(shape), axis=1).astype('float32')

        >>> target = paddle.uniform(shape, min=-10, max=10).astype('float32')

        >>> # 'batchmean' reduction, loss shape will be [], who is 0-D Tensor
        >>> pred_loss = F.kl_div(x, target, reduction='batchmean')
        >>> print(pred_loss.shape)
        paddle.Size([])

        >>> # 'mean' reduction, loss shape will be [], who is 0-D Tensor
        >>> pred_loss = F.kl_div(x, target, reduction='mean')
        >>> print(pred_loss.shape)
        paddle.Size([])

        >>> # 'sum' reduction, loss shape will be [], who is 0-D Tensor
        >>> pred_loss = F.kl_div(x, target, reduction='sum')
        >>> print(pred_loss.shape)
        paddle.Size([])

        >>> # 'none' reduction, loss shape is same with input shape
        >>> pred_loss = F.kl_div(x, target, reduction='none')
        >>> print(pred_loss.shape)
        paddle.Size([5, 20])

        >>> # if label is in the log space, set log_target = True
        >>> target = paddle.uniform(shape, min=0, max=10).astype('float32')
        >>> log_target = paddle.log(target)
        >>> pred_loss_1 = F.kl_div(x, target, reduction='none')
        >>> pred_loss_2 = F.kl_div(x, log_target, reduction='none', log_target=True)
        >>> print(paddle.allclose(pred_loss_1, pred_loss_2))
        Tensor(shape=[], dtype=bool, place=Place(cpu), stop_gradient=True,
        True)

r+   r,   r   r   r   	batchmeanr   kl_divr7   r!   r   rC   
kldiv_loss)r   TargetrF   )r   
log_targetrG   )r  )r   data_feederconvert_dtyper)   r*   castr   r   r  r   r   r/   r0   r   rL   r   r   strrM   rN   )	r7   r!   r   r  r9   r   rf   rO   rP   s	            r>   r  r    s>   @ 	&&u{{3y@**5;;79DE9-&&u{{3y@**5;;79DE9-fjA++c"C 
 %**S/C
 
	 +%5;;!#"[[^
jjo
2
22 7Y	2H	
 	!7Y	2H	
 	##I{CJ88u{{8K0TN &jA	 	 	
 ;;t$D  %::d#D  +%e,Q/J::d#j0Dr@   c                   US;  a  [        SU S35      e[        5       (       d   [        U SSS/S5        [        USSS/S5        US	:X  a)  [        R                  " [        R
                  " X5      US
9$ US:X  a=  [        R                  " [        R                  " [        R
                  " X5      5      US
9$ [        R                  " [        R                  " [        R
                  " X5      5      US
9$ )a6  
Accept input predications and label and returns the mean square error.

If :attr:`reduction` is set to ``'none'``, loss is calculated as:

.. math::
    Out = (input - label)^2

If :attr:`reduction` is set to ``'mean'``, loss is calculated as:

.. math::
    Out = \operatorname{mean}((input - label)^2)

If :attr:`reduction` is set to ``'sum'``, loss is calculated as:

.. math::
    Out = \operatorname{sum}((input - label)^2)

Parameters:
    input (Tensor): Input tensor, the data type should be float32 or float64.
    label (Tensor): Label tensor, the data type should be float32 or float64.
    reduction (string, optional): The reduction method for the output,
        could be 'none' | 'mean' | 'sum'.
        If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned.
        If :attr:`reduction` is ``'sum'``, the reduced sum loss is returned.
        If :attr:`reduction` is ``'none'``, the unreduced loss is returned.
        Default is ``'mean'``.
    name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.


Returns:
    Tensor, The tensor tensor storing the mean square error difference of input and label.

Examples:

    .. code-block:: python

        >>> import paddle
        >>> mse_loss = paddle.nn.loss.MSELoss()
        >>> input = paddle.to_tensor(1.5)
        >>> label = paddle.to_tensor(1.7)
        >>> output = mse_loss(input, label)
        >>> print(output)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               0.04000002)

r   zJ'reduction' in 'mse_loss' should be 'sum', 'mean' or 'none', but received r$   r7   r+   r,   mse_lossr!   r   r   r   )r`   r	   r   r*   r{   r   r   r   )r7   r!   r   r9   s       r>   r  r  $  s    l //%;a)
 	

  7Y	2J	
 	!7Y	2J	
 F}}V__U:FF	f	{{MM&//%78t
 	
 zzMM&//%78t
 	
r@   c                       SS jnU" XXFX#5      n	[         R                  " U	S/5      n	U(       aB  [         R                  " U	5      n
[         R                  " U	5      n[         R                  " U
UU	S9n	US;   d   eUS:X  a3  [         R
                  " XR                  U	R                  5      -  5      n	U	$ US:X  a  [         R                  " U	5      n	U	$ )a  

An operator integrating the open source Warp-CTC library (https://github.com/baidu-research/warp-ctc)
to compute Connectionist Temporal Classification (CTC) loss.
It can be aliased as softmax with CTC, since a native softmax activation
is integrated to the Warp-CTC library to normalize values for each row of the input tensor.

Parameters:
    log_probs (Tensor): The unscaled probability sequence with padding, which is a 3-D Tensor. The tensor shape is [max_logit_length, batch_size, num_classes + 1], where max_logit_length is the longest length of input logit sequence. The data type should be float32 or float64.
    labels (Tensor): The ground truth sequence with padding, which must be a 3-D Tensor. The tensor shape is [batch_size, max_label_length], where max_label_length is the longest length of label sequence. The data type must be int32.
    input_lengths (Tensor): The length for each input sequence, it should have shape [batch_size] and dtype int64.
    label_lengths (Tensor): The length for each label sequence, it should have shape [batch_size] and dtype int64.
    blank (int, optional): The blank label index of Connectionist Temporal Classification (CTC) loss, which is in the half-opened interval [0, num_classes + 1). The data type must be int32. Default: 0.
    reduction (str, optional): Indicate how to average the loss, the candidates are ``'none'`` | ``'mean'`` | ``'sum'``. If :attr:`reduction` is ``'mean'``, the output loss will be divided by the label_lengths, and then return the mean of quotient; If :attr:`reduction` is ``'sum'``, return the sum of loss; If :attr:`reduction` is ``'none'``, no reduction will be applied. Default: ``'mean'``.
    norm_by_times (bool, optional): Whether to normalize the gradients by the number of time-step, which is also the sequence's length. There is no need to normalize the gradients if reduction mode is 'mean'. Default: False.
    zero_infinity (bool, optional): If True, set infinite loss to zero. Default: False.

Returns:
    Tensor, The Connectionist Temporal Classification (CTC) loss between ``log_probs`` and  ``labels``. If attr:`reduction` is ``'none'``, the shape of loss is [batch_size], otherwise, the shape of loss is []. Data type is the same as ``log_probs``.

Examples:

    .. code-block:: python

        >>> # declarative mode
        >>> import paddle.nn.functional as F
        >>> import paddle
        >>> import numpy as np

        >>> # length of the longest logit sequence
        >>> max_seq_length = 4
        >>> #length of the longest label sequence
        >>> max_label_length = 3
        >>> # number of logit sequences
        >>> batch_size = 2
        >>> # class num
        >>> class_num = 3

        >>> log_probs = paddle.to_tensor(np.array([
        ...     [[4.17021990e-01, 7.20324516e-01, 1.14374816e-04],
        ...      [3.02332580e-01, 1.46755889e-01, 9.23385918e-02]],
        ...     [[1.86260208e-01, 3.45560730e-01, 3.96767467e-01],
        ...      [5.38816750e-01, 4.19194520e-01, 6.85219526e-01]],
        ...     [[2.04452246e-01, 8.78117442e-01, 2.73875929e-02],
        ...      [6.70467496e-01, 4.17304814e-01, 5.58689833e-01]],
        ...     [[1.40386939e-01, 1.98101491e-01, 8.00744593e-01],
        ...      [9.68261600e-01, 3.13424170e-01, 6.92322612e-01]],
        ...     [[8.76389146e-01, 8.94606650e-01, 8.50442126e-02],
        ...      [3.90547849e-02, 1.69830427e-01, 8.78142476e-01]]
        ... ]), dtype="float32")
        >>> labels = paddle.to_tensor([[1, 2, 2],
        ...     [1, 2, 2]], dtype="int32")
        >>> input_lengths = paddle.to_tensor([5, 5], dtype="int64")
        >>> label_lengths = paddle.to_tensor([3, 3], dtype="int64")

        >>> loss = F.ctc_loss(log_probs, labels,
        ...     input_lengths,
        ...     label_lengths,
        ...     blank=0,
        ...     reduction='none')
        >>> print(loss)
        Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True,
               [3.91798496, 2.90765190])

        >>> loss = F.ctc_loss(log_probs, labels,
        ...     input_lengths,
        ...     label_lengths,
        ...     blank=0,
        ...     reduction='mean')
        >>> print(loss)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               1.13760614)

c                   [        5       (       a+  Ub  Uc  [        S5      e[        R                  " XXEX#5      nU$ [	        S0 [        5       D6n[        U SSS/S5        [        USS/S5        U /U/S.nUb-  Ub*  [        US	S
/S5        [        USS
/S5        U/US	'   U/US'   UR                  U R                  S9nUR                  U R                  S9n	UR                  SUU	/U/S.UUS.S9  U$ )Nz?input_length and label_length must not be None in dygraph mode!warpctcr7   r+   r,   r!   r-   r\   LogitsLengthr.   LabelLengthrC   )WarpCTCGradrF   )blanknorm_by_timesrG   )r  )
r   r`   r   r  r   rL   r   rM   r)   rN   )
r7   r!   r  r  r   r   r  rO   r   grad_outs
             r>   r  ctc_loss.<locals>.warpctc  sM    "###|'; U  ~~l%H O 7fh7F$wI 6	 %UGgY	J&+Ww?K'L,D( .7)Y ) -'I 0<nN+.:^M*@@kk A H @@kk A H ")1
XJG"%2	   Or@   r%   )	conditionr   r   r   r   r   )r   FNN)	r*   r1   isinfr  r  r   rz   r)   r   )	log_probsrn   input_lengthslabel_lengthsr  r   r  zero_infinityr  r  inf_mask
zero_values               r>   ctc_lossr'  t  s    p 2h 5H ~~h-H<<)&&x0
<<
 ////F;;x*>*>x~~*NNO O 
e	::h'Or@   c                     SS jnU R                   S   n	U" XX#XE5      n
US;   d   eUS:X  a  [        R                  " XS9U	-  n
U
$ US:X  a  [        R                  " XS9n
U
$ )a  
An operator integrating the open source Warp-Transducer library (https://github.com/b-flo/warp-transducer.git)
to compute Sequence Transduction with Recurrent Neural Networks (RNN-T) loss.

Parameters:
    input (Tensor): The logprobs sequence with padding, which is a 4-D Tensor. The tensor shape is [B, Tmax, Umax, D], where Tmax is the longest length of input logit sequence. The data type should be float32 or float64.
    label (Tensor): The ground truth sequence with padding, which must be a 2-D Tensor. The tensor shape is [B, Umax], where Umax is the longest length of label sequence. The data type must be int32.
    input_lengths (Tensor): The length for each input sequence, it should have shape [batch_size] and dtype int64.
    label_lengths (Tensor): The length for each label sequence, it should have shape [batch_size] and dtype int64.
    blank (int, optional): The blank label index of RNN-T loss, which is in the half-opened interval [0, B). The data type must be int32. Default is 0.
    fastemit_lambda (float, default 0.001): Regularization parameter for FastEmit (https://arxiv.org/pdf/2010.11148.pdf)
    reduction (string, optional): Indicate how to average the loss, the candidates are ``'none'`` | ``'mean'`` | ``'sum'``. If :attr:`reduction` is ``'mean'``, the output will be sum of loss and be divided by the batch_size; If :attr:`reduction` is ``'sum'``, return the sum of loss; If :attr:`reduction` is ``'none'``, no reduction will be applied. Default is ``'mean'``.
    name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.

Returns:
    Tensor, The RNN-T loss between ``logprobs`` and  ``labels``. If attr:`reduction` is ``'none'``, the shape of loss is [batch_size], otherwise, the shape of loss is []. Data type is the same as ``logprobs``.

Examples:

    .. code-block:: python

        >>> # declarative mode
        >>> import paddle.nn.functional as F
        >>> import numpy as np
        >>> import paddle
        >>> import functools

        >>> fn = functools.partial(F.rnnt_loss, reduction='sum', fastemit_lambda=0.0, blank=0)

        >>> acts = np.array([[
        ...     [[0.1, 0.6, 0.1, 0.1, 0.1],
        ...      [0.1, 0.1, 0.6, 0.1, 0.1],
        ...      [0.1, 0.1, 0.2, 0.8, 0.1]],
        ...     [[0.1, 0.6, 0.1, 0.1, 0.1],
        ...      [0.1, 0.1, 0.2, 0.1, 0.1],
        ...      [0.7, 0.1, 0.2, 0.1, 0.1]]
        ... ]])
        >>> labels = [[1, 2]]

        >>> acts = paddle.to_tensor(acts, stop_gradient=False)

        >>> lengths = [acts.shape[1]] * acts.shape[0]
        >>> label_lengths = [len(l) for l in labels]
        >>> labels = paddle.to_tensor(labels, paddle.int32)
        >>> lengths = paddle.to_tensor(lengths, paddle.int32)
        >>> label_lengths = paddle.to_tensor(label_lengths, paddle.int32)

        >>> costs = fn(acts, labels, lengths, label_lengths)
        >>> print(costs)
        Tensor(shape=[], dtype=float64, place=Place(cpu), stop_gradient=False,
               -2.85042444)

r   c                   [        5       (       a  [        R                  " U UUUUU5      nU$ [        S0 [	        5       D6n[        U SSS/S5        [        USS/S5        [        USS/S5        [        USS/S5        U /U/U/U/S	.nUR                  U R                  S
9nUR                  U R                  S
9n	UR                  SUU	/U/S.UUS.S9  U$ )Nwarprnntr7   r+   r,   r!   r-   r"  r#  )r7   r!   r"  r#  rC   )warprnntgradrP   )r  fastemit_lambdarG   )r*  )	r   r   r*  r   rL   r   rM   r)   rN   )
r7   r!   r   r   r  r,  r  rO   r   r  s
             r>   r*  rnnt_loss.<locals>.warprnntS  s    "##H O4684 7Y	2J	
 	!'JG /G9j	
 	!/G9j	
 WW*^*^	
 <<5;;<O<<5;;<O&.Z(D#2	 	 	
 r@   r   r   r   r   )r   MbP?)r0   r*   r   )r7   r!   r"  r#  r  r,  r   r9   r*  Br  s              r>   	rnnt_lossr0    s    B LQ+Z 	AA mEH ////F::h2Q6 O 
e	::h2Or@   c	                    g N 	rb   r!   margin1margin2margin3scalegrouprc   r   s	            r>   margin_cross_entropyr:    s      r@   c	                    g r2  r3  r4  s	            r>   r:  r:    s     r@   c	                    g r2  r3  r4  s	            r>   r:  r:    s     &)r@   c	                   US;   d   eUSL d#  Ub   [        US5      (       d  [        SU S35      e[        US5      (       a  UR                  5       (       d  gSn	Sn
SnUSLa  Uc  SOUR                  n	[        R
                  " 5       (       a[  [        R                  R                  5       nUR                  nUc  UOUR                  U5      n
Uc  UR                  OUR                  nU R                  S	   S:X  a  [        S
U R                   S35      e[        [        U R                  5      5      n[        [        UR                  5      5      nUS-
  U:w  a  X:w  a  [        SU SU S35      eUS-
  U:X  a  [        R                   " US	S9n[#        5       (       a  U R$                  nU[        R&                  :X  a%  [        R(                  " U [        R*                  5      n [,        R.                  " U UUU	U
UUUUU5
      u  nnUS:X  a  [        R0                  " U5      nOUS:X  a  [        R2                  " U5      nU[        R&                  :X  a.  [        R(                  " UU5      n[        R(                  " UU5      nU(       d  U$ UU4$ Sn[5        U40 [7        5       D6nUR9                  U R$                  S9nUR9                  U R$                  S9n[;        U S/ SQS5        [;        USSS/S5        UR=                  UXS.UUS.UU	U
UUUUUS.S9  US:X  a  [        R0                  " U5      nOUS:X  a  [        R2                  " U5      nU(       d  U$ UU4$ )a6$  
.. math::

    L=-\frac{1}{N}\sum^N_{i=1}\log\frac{e^{s(cos(m_{1}\theta_{y_i}+m_{2})-m_{3})}}{e^{s(cos(m_{1}\theta_{y_i}+m_{2})-m_{3})}+\sum^n_{j=1,j\neq y_i} e^{scos\theta_{y_i}}}

where the :math:`\theta_{y_i}` is the angle between the feature :math:`x` and
the representation of class :math:`i`. The details of ArcFace loss
could be referred to https://arxiv.org/abs/1801.07698.

.. hint::
    The API supports single GPU and multi GPU, and don't supports CPU.
    For data parallel mode, set ``group=False``.
    For model parallel mode, set ``group=None`` or the group instance return by paddle.distributed.new_group.
    And logits.shape[-1] can be different at each rank.

Args:
    logits (Tensor): shape[N, local_num_classes], the output of the normalized X multiply the normalized W.
            The logits is shard_logits when using model parallel.
    label (Tensor): shape[N] or shape[N, 1], the ground truth label.
    margin1 (float, optional): m1 of margin loss, default value is `1.0`.
    margin2 (float, optional): m2 of margin loss, default value is `0.5`.
    margin3 (float, optional): m3 of margin loss, default value is `0.0`.
    scale (float, optional): s of margin loss, default value is `64.0`.
    group (Group, optional): The group instance return by paddle.distributed.new_group
        or ``None`` for global default group or ``False`` for data parallel (do not communication cross ranks).
        Default is ``None``.
    return_softmax (bool, optional): Whether return softmax probability. Default value is `False`.
    reduction (str|None, optional): The candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
                If :attr:`reduction` is ``'mean'``, return the average of loss;
                If :attr:`reduction` is ``'sum'``, return the sum of loss;
                If :attr:`reduction` is ``'none'``, no reduction will be applied.
                Default value is `'mean'`.

Returns:
    Tensor|tuple[Tensor, Tensor], return the cross entropy loss if
        `return_softmax` is False, otherwise the tuple (loss, softmax),
        softmax is shard_softmax when using model parallel, otherwise
        softmax is in the same shape with input logits. If
        ``reduction == None``, the shape of loss is ``[N, 1]``, otherwise
        the shape is ``[]``.

Examples:

    .. code-block:: python
        :name: code-example1

        >>> # doctest: +REQUIRES(env:GPU)
        >>> import paddle
        >>> paddle.seed(2023)
        >>> paddle.device.set_device('gpu')
        >>> m1 = 1.0
        >>> m2 = 0.5
        >>> m3 = 0.0
        >>> s = 64.0
        >>> batch_size = 2
        >>> feature_length = 4
        >>> num_classes = 4

        >>> label = paddle.randint(low=0, high=num_classes, shape=[batch_size], dtype='int64')

        >>> X = paddle.randn(
        ...     shape=[batch_size, feature_length],
        ...     dtype='float64')
        >>> X_l2 = paddle.sqrt(paddle.sum(paddle.square(X), axis=1, keepdim=True))
        >>> X = paddle.divide(X, X_l2)

        >>> W = paddle.randn(
        ...     shape=[feature_length, num_classes],
        ...     dtype='float64')
        >>> W_l2 = paddle.sqrt(paddle.sum(paddle.square(W), axis=0, keepdim=True))
        >>> W = paddle.divide(W, W_l2)

        >>> logits = paddle.matmul(X, W)
        >>> loss, softmax = paddle.nn.functional.margin_cross_entropy(
        ...     logits, label, margin1=m1, margin2=m2, margin3=m3, scale=s, return_softmax=True, reduction=None)
        >>> print(logits)
        Tensor(shape=[2, 4], dtype=float64, place=Place(gpu:0), stop_gradient=True,
               [[-0.59561850,  0.32797505,  0.80279214,  0.00144975],
                [-0.16265212,  0.84155098,  0.62008629,  0.79126072]])
        >>> print(label)
        Tensor(shape=[2], dtype=int64, place=Place(gpu:0), stop_gradient=True,
               [1, 0])
        >>> print(loss)
        Tensor(shape=[2, 1], dtype=float64, place=Place(gpu:0), stop_gradient=True,
               [[61.94391901],
                [93.30853839]])
        >>> print(softmax)
        Tensor(shape=[2, 4], dtype=float64, place=Place(gpu:0), stop_gradient=True,
               [[0.00000000, 0.00000000, 1.        , 0.00000000],
                [0.00000000, 0.96152676, 0.00000067, 0.03847257]])

    .. code-block:: python
        :name: code-example2

        >>> # doctest: +REQUIRES(env:DISTRIBUTED)
        >>> # Multi GPU, test_margin_cross_entropy.py
        >>> from typing import List
        >>> import paddle
        >>> import paddle.distributed as dist
        >>> paddle.seed(2023)
        >>> strategy = dist.fleet.DistributedStrategy()
        >>> dist.fleet.init(is_collective=True, strategy=strategy)
        >>> rank_id = dist.get_rank()
        >>> m1 = 1.0
        >>> m2 = 0.5
        >>> m3 = 0.0
        >>> s = 64.0
        >>> batch_size = 2
        >>> feature_length = 4
        >>> num_class_per_card = [4, 8]
        >>> num_classes = paddle.sum(paddle.to_tensor(num_class_per_card))

        >>> label = paddle.randint(low=0, high=num_classes.item(), shape=[batch_size], dtype='int64')  # type: ignore[arg-type]
        >>> label_list: List[paddle.Tensor] = []
        >>> dist.all_gather(label_list, label)
        >>> label = paddle.concat(label_list, axis=0)

        >>> X = paddle.randn(
        ...     shape=[batch_size, feature_length],
        ...     dtype='float64'
        ... )
        >>> X_list: List[paddle.Tensor] = []
        >>> dist.all_gather(X_list, X)
        >>> X = paddle.concat(X_list, axis=0)
        >>> X_l2 = paddle.sqrt(paddle.sum(paddle.square(X), axis=1, keepdim=True))
        >>> X = paddle.divide(X, X_l2)

        >>> W = paddle.randn(
        ...     shape=[feature_length, num_class_per_card[rank_id]],
        ...     dtype='float64')
        >>> W_l2 = paddle.sqrt(paddle.sum(paddle.square(W), axis=0, keepdim=True))
        >>> W = paddle.divide(W, W_l2)

        >>> logits = paddle.matmul(X, W)
        >>> loss, softmax = paddle.nn.functional.margin_cross_entropy(
        ...     logits, label, margin1=m1, margin2=m2, margin3=m3, scale=s, return_softmax=True, reduction=None)
        >>> print(logits)
        >>> print(label)
        >>> print(loss)
        >>> print(softmax)

        >>> # python -m paddle.distributed.launch --gpus=0,1 --log_dir log test_margin_cross_entropy.py
        >>> # cat log/workerlog.0
        >>> # Tensor(shape=[4, 4], dtype=float64, place=Place(gpu:0), stop_gradient=True,
        >>> #        [[-0.59561850,  0.32797505,  0.80279214,  0.00144975],
        >>> #         [-0.16265212,  0.84155098,  0.62008629,  0.79126072],
        >>> #         [-0.59561850,  0.32797505,  0.80279214,  0.00144975],
        >>> #         [-0.16265212,  0.84155098,  0.62008629,  0.79126072]])
        >>> # Tensor(shape=[4], dtype=int64, place=Place(gpu:0), stop_gradient=True,
        >>> #        [5, 4, 5, 4])
        >>> # Tensor(shape=[4, 1], dtype=float64, place=Place(gpu:0), stop_gradient=True,
        >>> #        [[104.27437027],
        >>> #         [113.40243782],
        >>> #         [104.27437027],
        >>> #         [113.40243782]])
        >>> # Tensor(shape=[4, 4], dtype=float64, place=Place(gpu:0), stop_gradient=True,
        >>> #        [[0.00000000, 0.00000000, 0.01210039, 0.00000000],
        >>> #         [0.00000000, 0.96152674, 0.00000067, 0.03847257],
        >>> #         [0.00000000, 0.00000000, 0.01210039, 0.00000000],
        >>> #         [0.00000000, 0.96152674, 0.00000067, 0.03847257]])
        >>> # cat log/workerlog.1
        >>> # Tensor(shape=[4, 8], dtype=float64, place=Place(gpu:1), stop_gradient=True,
        >>> #        [[-0.34913275, -0.35180883, -0.53976657, -0.75234331,  0.70534995,
        >>> #           0.87157838,  0.31064437,  0.19537700],
        >>> #         [-0.63941012, -0.05631600, -0.02561853,  0.09363013,  0.56571130,
        >>> #           0.13611246,  0.08849565,  0.39219619],
        >>> #         [-0.34913275, -0.35180883, -0.53976657, -0.75234331,  0.70534995,
        >>> #           0.87157838,  0.31064437,  0.19537700],
        >>> #         [-0.63941012, -0.05631600, -0.02561853,  0.09363013,  0.56571130,
        >>> #           0.13611246,  0.08849565,  0.39219619]])
        >>> # Tensor(shape=[4], dtype=int64, place=Place(gpu:1), stop_gradient=True,
        >>> #        [5, 4, 5, 4])
        >>> # Tensor(shape=[4, 1], dtype=float64, place=Place(gpu:1), stop_gradient=True,
        >>> #        [[104.27437027],
        >>> #         [113.40243782],
        >>> #         [104.27437027],
        >>> #         [113.40243782]])
        >>> # Tensor(shape=[4, 8], dtype=float64, place=Place(gpu:1), stop_gradient=True,
        >>> #        [[0.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00002368, 0.98787593,
        >>> #          0.00000000, 0.00000000],
        >>> #         [0.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00000002, 0.00000000,
        >>> #          0.00000000, 0.00000000],
        >>> #         [0.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00002368, 0.98787593,
        >>> #          0.00000000, 0.00000000],
        >>> #         [0.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00000002, 0.00000000,
        >>> #          0.00000000, 0.00000000]])

)r   r   r   NFN	is_memberzjExpected group is False, None or instance of paddle.distributed.collective.Group              (got group: rU   r   r&   r%   z,Expected logit_dims[-1] > 0 (got logit_dims rS   rT   r'   r   r   r:  rC   rb   r   r!   r-   r.   r\   rZ   )rc   ring_idranknranksr5  r6  r7  r8  rG   )hasattrr`   r>  idr   is_compiled_with_distr*   distributedParallelEnvr@  get_group_rank
world_sizerA  r0   r/   r5   	unsqueezer   r)   r   r  r+   r   r:  r   r   r   rL   rM   r   rN   )rb   r!   r5  r6  r7  r8  r9  rc   r   r?  r@  rA  parallel_envglobal_rankrd   re   out_typerh   rP   op_typerO   s                        r>   r:  r:    sa   P 5555UNemwuk/J/J#
 	
 uk""5??+<+<GDFE}!%((%%''!--99;L&++K = ))+6 
 16\,,5<<F||B1:6<<.J
 	
 T&,,'(JT%++&'JA~#
(@'LZLC
 	
 A~#  R0<<v~~%[[8F33
 ;;t$D%::d#Dv~~%kk'84G;;tX.DK= (W11;;&,,;O88v||8L -"		
 	!7Wg.0F	
 	$5 '6"0" """		 	 	
  ;;t$D%::d#DK= r@   c                    g r2  r3  rb   r!   rV   rW   rX   rc   r(   s          r>   rY   rY   	  s      r@   c                    g r2  r3  rO  s          r>   rY   rY    
  s     r@   c                    g r2  r3  rO  s          r>   rY   rY   
  s     &)r@   z2.0.0z"paddle.nn.functional.cross_entropyr&   zPlease notice that behavior of "paddle.nn.functional.softmax_with_cross_entropy" and "paddle.nn.functional.cross_entropy" is different.)since	update_tolevelreasonc           	     $    [        U UUUUUU5      $ )a  
This operator implements the cross entropy loss function with softmax. This function
combines the calculation of the softmax operation and the cross entropy loss function
to provide a more numerically stable gradient.

Because this operator performs a softmax on logits internally, it expects
unscaled logits. This operator should not be used with the output of
softmax operator since that would produce incorrect results.

When the attribute :attr:`soft_label` is set :attr:`False`, this operators
expects mutually exclusive hard labels, each sample in a batch is in exactly
one class with a probability of 1.0. Each sample in the batch will have a
single label.

The equation is as follows:

1) Hard label (one-hot label, so every sample has exactly one class)

.. math::
    \\loss_j=-\text{logits}_{label_j} +\log\left(\sum_{i=0}^{K}\exp(\text{logits}_i)\right), j = 1,..., K

2) Soft label (each sample can have a distribution over all classes)

.. math::
    \\loss_j= -\sum_{i=0}^{K}\text{label}_i\left(\text{logits}_i - \log\left(\sum_{i=0}^{K}\exp(\text{logits}_i)\right)\right), j = 1,...,K

3) If :attr:`numeric_stable_mode` is :attr:`True`, softmax is calculated first by:

.. math::
    \\max_j&=\max_{i=0}^{K}{\text{logits}_i} \\
            log\_max\_sum_j &= \log\sum_{i=0}^{K}\exp(logits_i - max_j)\\
            softmax_j &= \exp(logits_j - max_j - {log\_max\_sum}_j)

and then cross entropy loss is calculated by softmax and label.

Args:
    logits (Tensor): A multi-dimension ``Tensor`` , and the data type is float32 or float64. The input tensor of unscaled log probabilities.
    label (Tensor): The ground truth  ``Tensor`` , data type is the same
        as the ``logits`` . If :attr:`soft_label` is set to :attr:`True`,
        Label is a ``Tensor``  in the same shape with :attr:`logits`.
        If :attr:`soft_label` is set to :attr:`True`, Label is a ``Tensor``
        in the same shape with :attr:`logits` expect shape in dimension :attr:`axis` as 1.
    soft_label (bool, optional): A flag to indicate whether to interpret the given
        labels as soft labels. Default False.
    ignore_index (int, optional): Specifies a target value that is ignored and does
                                  not contribute to the input gradient. Only valid
                                  if :attr:`soft_label` is set to :attr:`False`.
                                  Default: kIgnoreIndex(-100).
    numeric_stable_mode (bool, optional): A flag to indicate whether to use a more
                                          numerically stable algorithm. Only valid
                                          when :attr:`soft_label` is :attr:`False`
                                          and GPU is used. When :attr:`soft_label`
                                          is :attr:`True` or CPU is used, the
                                          algorithm is always numerically stable.
                                          Note that the speed may be slower when use
                                          stable algorithm. Default: True.
    return_softmax (bool, optional): A flag indicating whether to return the softmax
                                     along with the cross entropy loss. Default: False.
    axis (int, optional): The index of dimension to perform softmax calculations. It
                          should be in range :math:`[-1, rank - 1]`, while :math:`rank`
                          is the rank of input :attr:`logits`. Default: -1.

Returns:
    - If `return_softmax` is False, return the cross entropy loss as a ``Tensor``.
      The dtype is the same as the input ``logits``. The shape is consistent with ``logits`` except in dimension :attr:`axis` as 1.
    - If `return_softmax` is True, return a tuple of two ``Tensor``: the cross entropy loss and the softmax result.
      The dtype of the cross entropy loss is the same as the input ``logits``, and the shape is consistent with ``logits``
      except in dimension :attr:`axis` as 1. The dtype and shape of the softmax result are the same as the input ``logits``.


Examples:
    .. code-block:: python

        >>> import paddle

        >>> logits = paddle.to_tensor([0.4, 0.6, 0.9], dtype="float32")
        >>> label = paddle.to_tensor([1], dtype="int64")

        >>> out = paddle.nn.functional.softmax_with_cross_entropy(logits=logits, label=label)
        >>> print(out)
        Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True,
               [1.15328646])

)ri   rO  s          r>   rY   rY   
  s'    L + r@   targetc
           	        US;  a  [        SU S35      eUS:  a  U(       a  [        SU S35      e[        [        U R                  5      5      n
U
S:X  a  [        S5      e[        [        UR                  5      5      nU
S-
  U:X  a  [        R
                  " XS9nU
S-
  U:w  a  X:w  a  [        S	U
 S
U S35      eUS:  a  SnU
S-
  U:X  aJ  [        R                  " XS9n[        R                  R                  R                  XR                  S   5      n[        R                  R                  R                  XS9nUR                  U R                  5      n[        [        UR                  5      5      n[        5       (       Ga  U(       d$  [        R                  " X:g  UR                  S9U-  n[        R                   " XXWSX65      u  pUGba  U(       a  [        R"                  " [        R                  " XR                  5      USSS9n[        UR                  5      n[%        UUS9n[        R                  " UUR                  5      n[        R&                  " UU5      nGOU R                  U   UR                  S   :w  a,  [        SU R                  U    SUR                  S    S35      e[        R                  " X:g  UR                  5      nUR(                  S:  a*  UR                  U   S:X  a  [        R                  " UU5      nUS:w  a  UWR(                  S-
  :w  a  [        [+        XlR(                  -  5      5      [        [+        XlR(                  -  S-   UR(                  5      5      -   XlR(                  -  /-   n[        R,                  " X,R/                  U5      5      nO[        R,                  " UW5      n[        R&                  " UU5      n[        UR                  5      n[%        UUS9n[        R                  " UUR                  5      n[        R&                  " UU5      nUS:X  a  [        R0                  " U/ SS5      $ US:X  Ga  S nSU R                  ;   a  U" U5      n[        R2                  " U5      $ US:  Gaw  UR                  [        R4                  :X  a(  [        R0                  " U/ [        R6                  S5      nO[        R0                  " U/ SS5      nX:g  nUc]  [        R                  " UUR                  S9n[        R0                  " U/ SS5      nUUUS:H  R                  UR                  5      -   -  nOu[        R                  " UWR                  5      n[        R&                  " UU5      n[        R0                  " U/ SS5      nUUUS:H  R                  UR                  5      -   -  nUR                  [        R4                  :X  a  [        R                  " UUR                  S9$ U$ UbV  [        R0                  " U/ SS5      n[        R0                  " W/ SS5      nUUUS:H  R                  UR                  5      -   -  $ [        R2                  " U5      $ U
S-
  U:X  a  [        R                  " XS9nU$ [9        U S/ SQS5        [9        US/ SQS5        [;        5       (       a  [        R                   " XXWSX65      u  nnOfUUSUUS .n[=        S*0 [?        5       D6nURA                  U R                  S9nURA                  U R                  S9nUUS".n URC                  S!XS#.U US$9  UGb}  [9        US%S&S'/S5        US(:X  a  U	OSn!U(       aw  [        R"                  " [        R                  " XR                  5      USSS9n[        UR                  5      n[%        UUS9n[        R                  " UUR                  5      nGOU R                  U   UR                  S   :w  a,  [        SU R                  U    SUR                  S    S35      e[        R&                  " [        R                  " X:g  UR                  S9U5      n[        R                  " X:g  U R                  5      nUR(                  S:  a*  UR                  U   S:X  a  [        R                  " UU5      nUS:w  a  XlR(                  S-
  :w  a  [        [+        XlR(                  -  5      5      [        [+        XlR(                  -  S-   UR(                  5      5      -   XlR(                  -  /-   n[        R,                  " U[        R.                  " UU5      5      nO[        R,                  " X,5      n[        R&                  " UU5      n[        UR                  5      n[%        UUS9n[        R&                  " UUU!S)9nUS:X  a  [        R0                  " XS)9$ US:X  Ga>  US:  a  [        R0                  " XS)9nX:g  nUcS  [        R                  " UUR                  S9n[        R0                  " UU	S)9nUU[        RD                  " US5      -   -  nU$ [        R                  " UWR                  5      n[        R&                  " UU5      n[        R0                  " UU	S)9nUU[        RD                  " US5      -   -  nU$ UbG  [        R0                  " XS)9n[        R0                  " W5      nUU[        RD                  " US5      -   -  $ [        RF                  " XS)9$ U
S-
  U:X  a  [        R                  " XS9nU$ )+a*  

By default, the cross entropy loss function is implemented using softmax. This function
combines the calculation of the softmax operation and the cross entropy loss function
to provide a more numerically stable computing.

Calculate the cross entropy loss function without softmax when use_softmax=False.

By default, calculate the mean of the result, and you can also affect
the default behavior by using the reduction parameter. Please refer to the part of
parameters for details.

Can be used to calculate the softmax cross entropy loss with soft and hard labels.
Where, the hard labels mean the actual label value, 0, 1, 2, etc.  And the soft labels
mean the probability of the actual label, 0.6, 0.8, 0.2, etc.

The calculation includes the following two steps.

- **1.softmax cross entropy**

    1. Hard label (each sample can only be assigned into one category)

    1.1. when use_softmax=True

        .. math::
          \\loss_j=-\text{logits}_{label_j}+\log\left(\sum_{i=0}^{C}\exp(\text{logits}_i)\right) , j = 1,...,N

        where, N is the number of samples and C is the number of categories.

    1.2. when use_softmax=False

        .. math::
          \\loss_j=-\log\left({P}_{label_j}\right) , j = 1,...,N

        where, N is the number of samples and C is the number of categories, P is input(the output of softmax).


    2. Soft label (each sample is assigned to multiple categories with a certain probability, and the probability sum is 1).

    2.1. when use_softmax=True

        .. math::
          \\loss_j=-\sum_{i=0}^{C}\text{label}_i\left(\text{logits}_i-\log\left(\sum_{i=0}^{C}\exp(\text{logits}_i)\right)\right) , j = 1,...,N

        where, N is the number of samples and C is the number of categories.

    2.2. when use_softmax=False

        .. math::
          \\loss_j=-\sum_{j=0}^{C}\left({label}_j*\log\left({P}_{label_j}\right)\right) , j = 1,...,N

        where, N is the number of samples and C is the number of categories, P is input(the output of softmax).




- **2. Weight and reduction processing**

    1. Weight

        If the ``weight`` parameter is ``None`` , go to the next step directly.

        If the ``weight`` parameter is not ``None`` , the cross entropy of each sample is weighted by weight
        according to soft_label = False or True as follows.

        1.1. Hard labels (soft_label = False)

        .. math::
            \\loss_j=loss_j*weight[label_j]


        1.2. Soft labels (soft_label = True)

         .. math::
            \\loss_j=loss_j*\sum_{i}\left(weight[label_i]*logits_i\right)

    2. reduction

        2.1 if the ``reduction`` parameter is ``none``

            Return the previous result directly

        2.2 if the ``reduction`` parameter is ``sum``

            Return the sum of the previous results

        .. math::
           \\loss=\sum_{j}loss_j

        2.3 if the ``reduction`` parameter is ``mean`` , it will be processed according to
        the ``weight`` parameter as follows.

        2.3.1. If the  ``weight``  parameter is ``None``

               Return the average value of the previous results

        .. math::
            \\loss=\sum_{j}loss_j/N

              where, N is the number of samples and C is the number of categories.

        2.3.2. If the 'weight' parameter is not 'None', the weighted average value of the previous result will be returned

        1. Hard labels (soft_label = False)

        .. math::
            \\loss=\sum_{j}loss_j/\sum_{j}weight[label_j]

        2. Soft labels (soft_label = True)

        .. math::
            \\loss=\sum_{j}loss_j/\sum_{j}\left(\sum_{i}weight[label_i]\right)


Parameters:
    input (Tensor): the data type is float32, float64. Shape is :math:`[N_1, N_2, ..., N_k, C]`, where C is number of classes, ``k >= 1`` .

        Note:
            1. when use_softmax=True, it expects unscaled logits. This operator should not be used with the output of softmax operator, which will produce incorrect results.
            2. when use_softmax=False, it expects the output of softmax operator.

    label (Tensor):
        1. If soft_label=False, the shape is
        :math:`[N_1, N_2, ..., N_k]` or :math:`[N_1, N_2, ..., N_k, 1]`, k >= 1.
        the data type is int32, int64, float32, float64, where each value is [0, C-1].

        2. If soft_label=True and no label_smoothing, the shape and data type
        should be same with ``input`` , and the sum of the labels for each sample should be 1.

        3. If has label_smoothing, (i.e. label_smoothing > 0.0), no matter what ``soft_label`` is,
        the shape and data type of ``label`` could be either the situation 1 or situation 2.
        In other words, if label_smoothing > 0.0, the format of label could be one-hot label or integer label.

        4. Alias Support: The parameter name ``label`` can be used as an alias for ``target``.
        For example, ``cross_entropy(label=tensor)`` is equivalent to ``cross_entropy(target=tensor)``.

    weight (Tensor, optional): a manual rescaling weight given to each class.
        If given, has to be a Tensor of size C and the data type is float32, float64.
        Default is ``'None'`` .
    ignore_index (int64, optional): Specifies a target value that is ignored
        and does not contribute to the loss. A negative value means that no label
        value needs to be ignored. Only valid when soft_label = False.
        Default is ``-100`` .
    reduction (str, optional): Indicate how to average the loss by batch_size,
        the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
        If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
        If :attr:`size_average` is ``'sum'``, the reduced sum loss is returned.
        If :attr:`reduction` is ``'none'``, the unreduced loss is returned.
        Default is ``'mean'``.
    soft_label (bool, optional): Indicate whether label is soft. Default is ``False``.
    label_smoothing (float, optional): A float in [0.0, 1.0].
        Specifies the amount of smoothing when computing the loss, where 0.0 means no smoothing.
        The targets become  a mixture of the original ground truth and a uniform distribution as
        described in paper 'Rethinking the Inception Architecture for Computer Vision'.
        Default is ``0.0``.
    axis (int, optional):The index of dimension to perform softmax calculations.
        It should be in range :math:`[-1, rank - 1]`, where :math:`rank` is the
        number of dimensions of input :attr:`input`.
        Default is ``-1`` .
    use_softmax (bool, optional): Indicate whether compute softmax before cross_entropy.
        Default is ``True``.
    name (str|None, optional): The name of the operator. Default is ``None`` .
        For more information, please refer to :ref:`api_guide_Name` .

Returns:

    Tensor. Return the softmax cross_entropy loss of ``input`` and ``label``.
    The data type is the same as input.

    If :attr:`reduction` is ``'mean'`` or ``'sum'`` , the dimension of return value is ``1``.

    If :attr:`reduction` is ``'none'``:

    1. If soft_label = False, the dimension of return value is the same with ``label`` .

    2. if soft_label = True, the dimension of return value is :math:`[N_1, N_2, ..., N_k, 1]` .

Examples:
    .. code-block:: python
        :name: code-example1

        >>> # hard labels
        >>> import paddle
        >>> paddle.seed(99999)
        >>> N=100
        >>> C=200
        >>> reduction='mean'
        >>> input =  paddle.rand([N, C], dtype='float64')
        >>> label =  paddle.randint(0, C, shape=[N], dtype='int64')
        >>> weight = paddle.rand([C], dtype='float64')

        >>> cross_entropy_loss = paddle.nn.loss.CrossEntropyLoss(
        ...     weight=weight, reduction=reduction)
        >>> dy_ret = cross_entropy_loss(
        ...                             input,
        ...                             label)

        >>> print(dy_ret)
        Tensor(shape=[], dtype=float64, place=Place(cpu), stop_gradient=True,
               5.35419278)

    .. code-block:: python
        :name: code-example2

        >>> # soft labels
        >>> # case1: soft labels without label_smoothing
        >>> import paddle
        >>> from typing import Optional
        >>> paddle.seed(99999)
        >>> axis = -1
        >>> N = 4
        >>> C = 3
        >>> shape = [N, C]
        >>> reduction='mean'
        >>> weight: Optional[paddle.Tensor] = None
        >>> logits = paddle.uniform(shape, dtype='float64', min=0.1, max=1.0)
        >>> labels = paddle.uniform(shape, dtype='float64', min=0.1, max=1.0)
        >>> labels /= paddle.sum(labels, axis=axis, keepdim=True)
        >>> paddle_loss_mean = paddle.nn.functional.cross_entropy(
        ...     logits,
        ...     labels,
        ...     soft_label=True,
        ...     axis=axis,
        ...     weight=weight,
        ...     reduction=reduction
        ... )
        >>> print(paddle_loss_mean)
        Tensor(shape=[], dtype=float64, place=Place(cpu), stop_gradient=True,
               1.12801195)


        >>> # case2: soft labels with label_smoothing
        >>> import paddle
        >>> from typing import Optional
        >>> paddle.seed(99999)
        >>> axis = -1
        >>> N = 4
        >>> C = 3
        >>> shape = [N, C]
        >>> label_smoothing = 0.4
        >>> reduction='mean'
        >>> weight: Optional[paddle.Tensor] = None
        >>> logits = paddle.uniform(shape, dtype='float64', min=0.1, max=1.0)
        >>> integer_labels = paddle.randint(low=0, high=C, shape=[N], dtype='int64')
        >>> one_hot_labels = paddle.nn.functional.one_hot(integer_labels, C).astype('float32')

        >>> # integer labels
        >>> paddle_integer_loss_mean = paddle.nn.functional.cross_entropy(
        ...     logits,
        ...     integer_labels,
        ...     axis=axis,
        ...     weight=weight,
        ...     label_smoothing=label_smoothing,
        ...     reduction=reduction
        ... )
        >>> print(paddle_integer_loss_mean)
        Tensor(shape=[], dtype=float64, place=Place(cpu), stop_gradient=True,
        1.08317309)

        >>> # one_hot labels
        >>> paddle_one_hot_loss_mean = paddle.nn.functional.cross_entropy(
        ...                                                         logits,
        ...                                                         one_hot_labels,
        ...                                                         axis=axis,
        ...                                                         weight=weight,
        ...                                                         label_smoothing=label_smoothing,
        ...                                                         reduction=reduction)
        >>> print(paddle_one_hot_loss_mean)
        Tensor(shape=[], dtype=float64, place=Place(cpu), stop_gradient=True,
        1.08317309)

r   zaThe value of 'reduction' in softmax_cross_entropyshould be 'sum', 'mean' or 'none', but received r   r   zlWhen soft_label == True, the value of 'ignore_index' in softmax_cross_entropyshould be '-100', but received rR   r&   r'   rS   rT   rU   r   Tr%   r8   rC   NF)r   r   rt   ru   rp   zinput's class_dimension(z)) must equal to weight's class_dimension(z) when weight is providedr   r   c                (    U [         R                  -   $ r2  )r*   nan)r   s    r>   _replace_nan#cross_entropy.<locals>._replace_nan  s    VZZ''r@   r7   )r   r   r+   r,   softmax_cross_entropyr!   )uint8int8int16r-   r.   r+   r,   )rV   rW   rX   r(   use_softmaxrY   rZ   r\   rG   r   r+   r,   r   r   r_   )$r`   r/   r5   r0   r*   rI  r1   r2   r3   r4   label_smoothrz   r)   r	   r  r   ra   r|   r   r   ndimr6   	gather_ndry   r   r   r   r+   r   r   r   rL   rM   rN   rx   r   )"r7   r!   r   rW   r   rV   r(   rb  label_smoothingr9   rd   re   valid_labelr   r   weight_gatherr   weight_gather_reshapeignore_weight_mask	temp_permr   r\  out_summaskcountretweight_ignored
weight_sumr   rh   rK   rO   rJ   r   s"                                     r>   r   r   
  s
   | //??HkI`b
 	
 aJ..:^;RT
 	

 T%++&'JQMNNT%++&'JA~#  2A~#
(@'LZLC
 	

 
 >Z'NN54EII((00BHE		$$11 2 
 U[[)ekk*+
E1EM  22*4
 
 !'kk%6 % $	! !O	(/Y(O%kk#'<'B'BCooc+@A;;t$R(88$25;;t3D2E F44:LL4D3E F22  &,[[*SYY&" '++a/*006!; *0*D*& 2:$+*:*:Q*>">U4*:*:#:;<!!%(8(8!81!<{?O?O  "2"2234  %+$4$4 5 5i @%M %+$4$4V[$IM &!#5! #5;;/(/!)% kk#'<'B'BCooc+@A ::c2tU33& ( EKK"3's++ q 99.$jjb&..%HG$jjb$>G ,>!;;t7==AD"JJtRu=E!Uesl-B-B5;;-O%OPC!;;t-B-H-HID%+__3&N "(NBe!LJ!"%,44Z5E5EFGC 99.!;;s#))<<J# **S"dE:%zz)2tU   #s*22<3E3EFG 
 s++ A~+nnS4J 	!7#		
 	!N#		
 ==!<<jt\LGS
 ) ,'+*E !JJF??kk @ G ;;%++;NC")37G1"'8	   $I&'	 #,v"5$4K !'kk%6 % $	! !O	(/Y(O%kk#'<'B'BC;;t$R(88$25;;t3D2E F44:LL4D3E F22  %ooKK 5U[[I5 &,[[*U[[&" '++a/*006!;)/*D*& 2:$*:*:Q*>">U4*:*:#:;<!!%(8(8!81!<{?O?O  "2"2234  %+$4$4 0 0i H%M %+$4$4V$IM &!#5! #5;;/(/!)% //#'<;OC::c--& q  **S4 ,>!;;t7==AD"JJt$7E!UV\\%-E%EFC 
 ";;t-B-H-HID%+__3&N "(N!FJ!Z&,,z32O%OPC
# **S4%zz*?@ 6<<c#BB  {{322 A~+nnS4Jr@   c           
        US;  a  [        SU S35      eUbE  [        USSS/S5        [        UR                  5      n[	        U5      nUS	:  a  [        S
U S35      e[        5       (       Ga8  [        5       n	[        R                  " [        R                  " U 5      SU R                  U	5      n
[        R                  " XSSS5      n[        R                  " U 5      n[        R                  " [        R                  " X5      [        R                  " [        R                  " X5      [        R                  " X5      5      5      n[        R                   " X;R                  S9n[        R                  " [        R                  " X15      [        R                  " [        R                  " X5      [        R                  " X5      5      5      n[        R                  " X5      n[#        5       (       a  [        R                   " XKR                  S9n[        R$                  " [        R                  " X5      U5      n[        R                  " X5      nUb  [        R&                  " X5      nUS:X  a  [        R(                  " U/ SS5      $ US:X  a  [        R*                  " U5      $ U$ [        U SSS/S5        [        USSS/S5        SnUS:X  a  Uc  Un[        R,                  R.                  R1                  XSSUS9n[        R,                  R.                  R                  U 5      nX-  S	U-
  S	U-
  -  -   nX1-  S	U-
  S	U-
  -  -   n[        R                  " X5      n[        R$                  " S	U-
  U5      n[        R                  " X5      nUb  US:X  a  UOSn[        R&                  " XUS9nUS:X  a  [        R2                  " XS9nU$ US:X  a  [        R(                  " XS9nU$ )ap  
`Focal Loss <https://arxiv.org/abs/1708.02002>`_ is proposed to address the
foreground-background class imbalance for classification tasks. It down-weights
easily-classified examples and thus focuses training on hard examples. For example,
it is used in one-stage object detection where the foreground-background class
imbalance is extremely high.

This operator measures focal loss function as follows:

.. math::
       Out = -Labels * alpha * {(1 - \sigma(Logit))}^{gamma}\log(\sigma(Logit)) - (1 - Labels) * (1 - alpha) * {\sigma(Logit)}^{gamma}\log(1 - \sigma(Logit))

We know that :math:`\sigma(Logit) = \frac{1}{1 + \exp(-Logit)}`.

Then, if :attr:`normalizer` is not None, this operator divides the
normalizer tensor on the loss `Out`:

.. math::
       Out = \frac{Out}{normalizer}

Finally, this operator applies reduce operation on the loss.
If :attr:`reduction` set to ``'none'``, the operator will return the original loss `Out`.
If :attr:`reduction` set to ``'mean'``, the reduced mean loss is :math:`Out = MEAN(Out)`.
If :attr:`reduction` set to ``'sum'``, the reduced sum loss is :math:`Out = SUM(Out)`.

Note that the target ``label`` is 0 for the negative class and is 1 for the positive class.

Args:
    logit (Tensor): The input logit tensor. The shape is [N, *], where N is batch_size,
        `*` means any number of additional dimensions. The ``logit`` is usually the
        output of a convolution layer. Available dtype is float32, float64.
    label (Tensor): The target label tensor with the same shape as
        ``logit``. The target label whose value should be numbers between 0 and 1.
        Available dtype is float32, float64.
    normalizer (Tensor, optional): The number normalizes the focal loss. It has to be
        a 1-D Tensor with shape `[1, ]` or 0-D Tensor with shape `[]`. The data type
        is float32, float64. For object detection task, it is the number of positive samples.
        If set to None, the focal loss will not be normalized. Default is None.
    alpha(int|float, optional): Hyper-parameter to balance the positive and negative example,
        it should be between 0 and 1.  Default value is set to 0.25.
    gamma(int|float, optional): Hyper-parameter to modulate the easy and hard examples.
        Default value is set to 2.0.
    reduction (str, optional): Indicate how to average the loss by batch_size,
        the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
        If :attr:`reduction` is ``'none'``, the unreduced loss is returned;
        If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
        If :attr:`reduction` is ``'sum'``, the summed loss is returned.
        Default is ``'sum'``.
    name (str|None, optional): Name for the operation (optional, default is None).
        For more information, please refer to :ref:`api_guide_Name`.

Returns:
    Tensor, if :attr:`reduction` is ``'mean'`` or ``'sum'``, the out shape is :math:`[]`, otherwise the shape is the same as ``logit``. The same dtype as ``logit`` tensor.

Examples:

    .. code-block:: python

        >>> import paddle

        >>> logit = paddle.to_tensor([[0.97, 0.91, 0.03], [0.55, 0.43, 0.71]], dtype='float32')
        >>> label = paddle.to_tensor([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype='float32')
        >>> one = paddle.to_tensor([1.], dtype='float32')
        >>> fg_label = paddle.greater_equal(label, one)
        >>> fg_num = paddle.sum(paddle.cast(fg_label, dtype='float32'))
        >>> output = paddle.nn.functional.sigmoid_focal_loss(logit, label, normalizer=fg_num)
        >>> print(output)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               0.65782464)

r   z_The value of 'reduction' in sigmoid_focal_loss should be 'sum', 'mean' or 'none', but received r   N
normalizerr+   r,   sigmoid_focal_lossr&   zKExpected zero or one dimension of normalizer in sigmoid_focal_loss but got r$   r   Fr    rC   r   r   r   r!   r   )r   r9   r   )r`   r   r5   r0   r/   r   r   r   r   r*   r)   r   sigmoidr   r   r   r   r	   powdivider   r   r2   r3   r   r   )r   r!   rs  alphagammar   r9   normalizer_shapenormalizer_dimsplacer   rP   predp_talpha_tgamma_tbce_namenormalizer_names                     r>   rt  rt    so   ` //??HkI`b
 	

  	" 		
  
 0 01./Q]^m]nnop  ')kk&,,u-sEKKG77$t
 ~~e$jjOOD(OO*FOOC,G
   jj9**OOE)OO+V__S-H
 w-$$U**=E**V__S6>w-!==2D::dBe44& ??4(( 	!7Y	24H	
 	!7Y	24H	
 :#5Hyy##DD$&x E 
 yy##++E2la$h1u955-1u9U";;w-**a#g.w-!&/6&9dtO==HD;;t/D  %::d.Dr@   c                   US;  a  [        SU S35      eU R                  UR                  :X  d%  [        SU R                   SUR                   35      e[        5       (       d   [        U SSS/S	5        [        US
SS/S	5        U[        R
                  R                  R                  U 5      -  SU-
  [        R
                  R                  R                  U * 5      -  -   * nUb#  [        5       (       d  [        USSS/S	5        XR-  nUR                  SS9nUS:X  a  U$ US:X  a  [        R                  " U5      $ US:X  a  [        R                  " U5      $ g)aM  
Calculate 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:

.. math::
    \text{loss}(x, y) = - \frac{1}{C} * \sum_i y[i] * \log((1 + \exp(-x[i]))^{-1})
        + (1-y[i]) * \log\left(\frac{\exp(-x[i])}{(1 + \exp(-x[i]))}\right)

where :math:`i \in \left\{0, \; \cdots , \; \text{x.nElement}() - 1\right\}`,
:math:`y[i] \in \left\{0, \; 1\right\}`.

Parameters:
    input (Tensor): Input tensor, the data type is float32 or float64. Shape is (N, C), where C is number of classes, and if shape is more than 2D, this is (N, C, D1, D2,..., Dk), k >= 1.
    label (Tensor): Label tensor, the data type is float32 or float64. The shape of label is the same as the shape of input.
    weight (Tensor, optional): a manual rescaling weight given to each class.
            If given, has to be a Tensor of size C and the data type is float32, float64.
            Default is ``'None'`` .
    reduction (str, optional): Indicate how to average the loss by batch_size,
            the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
            If :attr:`reduction` is ``'none'``, the unreduced loss is returned;
            If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
            If :attr:`reduction` is ``'sum'``, the summed loss is returned.
            Default: ``'mean'``
    name (str|None, optional): Name for the operation (optional, default is None).
            For more information, please refer to :ref:`api_guide_Name`.

Shape:
    input: N-D Tensor, the shape is [N, \*], N is batch size and `\*` means number of classes, available dtype is float32, float64. The sum operation operates over all the elements.
    label: N-D Tensor, same shape as the input.
    weight: N-D Tensor, the shape is [N,1]
    output: scalar. If :attr:`reduction` is ``'none'``, then same shape as the input.

Returns:
    Tensor, The tensor variable storing the multi_label_soft_margin_loss of input and label.

Examples:
    .. code-block:: python

        >>> import paddle
        >>> import paddle.nn.functional as F
        >>> input = paddle.to_tensor([[1, -2, 3], [0, -1, 2], [1, 0, 1]], dtype=paddle.float32)
        >>> # label elements in {1., -1.}
        >>> label = paddle.to_tensor([[-1, 1, -1], [1, 1, 1], [1, -1, 1]], dtype=paddle.float32)
        >>> loss = F.multi_label_soft_margin_loss(input, label, reduction='none')
        >>> print(loss)
        Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True,
               [3.49625897, 0.71111226, 0.43989015])
        >>> loss = F.multi_label_soft_margin_loss(input, label, reduction='mean')
        >>> print(loss)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               1.54908717)

r   z^'reduction' in 'multi_label_soft_margin_loss' should be 'sum', 'mean' or 'none', but received r$   z<The input and label should have same dimension,but received z!=r7   r+   r,   multi_label_soft_margin_lossr!   r&   Nr   r%   r'   r   r   r   )
r`   r0   r	   r   r*   r2   r3   log_sigmoidr   r   )r7   r!   r   r   r9   rP   s         r>   r  r    sy   | //%;a)
 	

 KK5;;&!KK=5;;-9
 	

  	"*		
 	!	"*		
 			$$0077u9		,,88%@
@	AD
   $I&.	 }99"9DF	f	{{4  	e	zz$ 
r@   c                   US;  a  [        SU S35      e[        5       (       d   [        U SSS/S5        [        USSS/S5        [        R                  " S	/U R
                  S
9n[        R                  " US:H  X5      [        R                  " US:H  [        R                  R                  R                  X -
  5      U5      -   nUS:X  a  [        R                  " XdS9$ US:X  a  [        R                  " XdS9$ US:X  a  U$ g)ab  
Calculates hinge_embedding_loss. Measures the loss given an input tensor :math:`x` and a labels tensor :math:`y`(containing 1 or -1).
This is usually used for measuring whether two inputs are similar or dissimilar, e.g. using the L1 pairwise distance as :math:`x`,
and is typically used for learning nonlinear embeddings or semi-supervised learning.

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`.

Parameters:
    input (Tensor): Input tensor, the data type is float32 or float64.
        the shape is [N, \*], N is batch size and `\*` means any number of additional dimensions, available dtype is float32, float64.
    label (Tensor): Label tensor containing 1 or -1, the data type is float32 or float64.
        The shape of label is the same as the shape of input.
    margin (float, optional): Specifies the hyperparameter margin to be used.
        The value determines how large the input need to be to calculate in
        hinge_embedding_loss. When label is -1, Input smaller than margin are minimized with hinge_embedding_loss.
        Default = 1.0
    reduction (str, optional): Indicate how to average the loss by batch_size.
        the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
        If :attr:`reduction` is ``'none'``, the unreduced loss is returned;
        If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
        If :attr:`reduction` is ``'sum'``, the summed loss is returned.
        Default: ``'mean'``
    name (str|None, optional): Name for the operation (optional, default is None).
        For more information, please refer to :ref:`api_guide_Name`.

Shape:

    input: N-D Tensor, the shape is [N, \*], N is batch size and `\*` means any number of additional dimensions, available dtype is float32, float64. The sum operation operates over all the elements.

    label: N-D Tensor, same shape as the input. tensor elements should containing 1 or -1, the data type is float32 or float64.

    output: scalar. If :attr:`reduction` is ``'none'``, then same shape as the input.

Returns:
    Tensor. The tensor variable storing the hinge_embedding_loss of input and label.

Examples:
    .. code-block:: python

        >>> import paddle
        >>> import paddle.nn.functional as F

        >>> input = paddle.to_tensor([[1, -2, 3], [0, -1, 2], [1, 0, 1]], dtype=paddle.float32)
        >>> # label elements in {1., -1.}
        >>> label = paddle.to_tensor([[-1, 1, -1], [1, 1, 1], [1, -1, 1]], dtype=paddle.float32)

        >>> loss = F.hinge_embedding_loss(input, label, margin=1.0, reduction='none')
        >>> print(loss)
        Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True,
               [[ 0., -2.,  0.],
                [ 0., -1.,  2.],
                [ 1.,  1.,  1.]])
        >>> loss = F.hinge_embedding_loss(input, label, margin=1.0, reduction='mean')
        >>> print(loss)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               0.22222222)

r   zV'reduction' in 'hinge_embedding_loss' should be 'sum', 'mean' or 'none', but received r$   r7   r+   r,   hinge_embedding_lossr!   r&   rC   r   g      r   r   r   r   N)r`   r	   r   r*   zerosr)   r  r2   r3   r   r   r   )r7   r!   r   r   r9   zero_rP   s          r>   r  r  	  s   d //%;a)
 	

  7Y	24J	
 	!7Y	24J	
 LL!EKK0E<<e3fllvyy++00@%7 D F{{4++	e	zz$**	f	 
r@   c                @   [        UR                  5      S:w  a  [        S5      eU R                  UR                  :w  a  [        S5      e[        U R                  5      S:  a  [        S5      eU R                  [        R
                  [        R                  4;  a  [        S5      eUR                  [        R                  [        R                  [        R
                  [        R                  4;  a  [        S5      eX-  R                  SS	9n[        R                  " U 5      R                  SS	9S
-   n[        R                  " U5      R                  SS	9S
-   n[        R                  " Xx-  5      n	Xi-  n
[        R                  " U
5      nSU
-
  n[        R                  " X-
  SS9n[        R                  " US:H  X5      n[        R                  " US:H  X5      nX-   nUS:X  a  U$ US:X  a  [        R                  " UUS9$ US:X  a  [        R                  " UUS9$ g)ah  
Compute the cosine embedding loss of Tensor ``input1``, ``input2`` and ``label`` as follows.

If label = 1, then the loss value can be calculated as follow:

.. math::
    Out = 1 - cos(input1, input2)

If label = -1, then the loss value can be calculated as follow:

.. math::
    Out = max(0, cos(input1, input2)) - margin

The operator cos can be described as follow:
 .. math::
    cos(x1, x2) = \frac{x1 \cdot{} x2}{\Vert x1 \Vert_2 * \Vert x2 \Vert_2}

Parameters:
    input1 (Tensor): tensor with shape: [N, M] or [M], 'N' means batch size, which can be 0, 'M' means the length of input array.
                     Available dtypes are float32, float64.
    input2 (Tensor): tensor with shape: [N, M] or [M], 'N' means batch size, which can be 0, 'M' means the length of input array.
                     Available dtypes are float32, float64.
    label (Tensor): tensor with shape: [N] or [1], 'N' means the length of input array. The target labels values should be -1 or 1.
                     Available dtypes are int32, int64, float32, float64.
    margin (float, optional): Should be a number from :math:`-1` to :math:`1`,
                     :math:`0` to :math:`0.5` is suggested. If :attr:`margin` is missing, the
                     default value is :math:`0`.
    reduction (string, optional): Specifies the reduction to apply to the output:
                     ``'none'`` | ``'mean'`` | ``'sum'``. ``'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.
    name (str, optional): Name for the operation (optional, default is None).
                     For more information, please refer to :ref:`api_guide_Name`.

Returns:
    Tensor, the cosine embedding Loss of Tensor ``input1`` ``input2`` and ``label``.
        If `reduction` is ``'none'``, the shape of output loss is [N], the same as ``input`` .
        If `reduction` is ``'mean'`` or ``'sum'``, the shape of output loss is [].

Examples:
    .. code-block:: python

        >>> import paddle

        >>> input1 = paddle.to_tensor([[1.6, 1.2, -0.5], [3.2, 2.6, -5.8]], 'float32')
        >>> input2 = paddle.to_tensor([[0.5, 0.5, -1.8], [2.3, -1.4, 1.1]], 'float32')
        >>> label = paddle.to_tensor([1, -1], 'int64')

        >>> output = paddle.nn.functional.cosine_embedding_loss(input1, input2, label, margin=0.5, reduction='mean')
        >>> print(output)  # 0.21155193
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               0.21155193)
        >>> output = paddle.nn.functional.cosine_embedding_loss(input1, input2, label, margin=0.5, reduction='sum')
        >>> print(output)  # 0.42310387
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               0.42310387)
        >>> output = paddle.nn.functional.cosine_embedding_loss(input1, input2, label, margin=0.5, reduction='none')
        >>> print(output)  # [0.42310387, 0.        ]
        Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True,
               [0.42310387, 0.        ])

r&   z51D target tensor expected, multi-target not supportedzdthe shape of input tensor 1 should be equal to input tensor 2, but found inputs with different sizesr#   zV1D target tensor expects 1D or 2D input tensors, but found inputs with different sizes>The data type of input Variable must be 'float32' or 'float64'zNThe data type of label Variable must be 'int32', 'int64', 'float32', 'float64'r%   r'   gdy=r   minr   r   r   r   N)r/   r0   r`   r)   r*   r+   r,   r-   r.   r   r{   sqrtr  clipr  r   )input1input2r!   r   r   r9   prod_summag_square1mag_square2denomcosr  posr   out_posout_negr   s                    r>   cosine_embedding_lossr  v  s   L 5;;1C
 	
 ||v||#
 	

 6<<1d
 	
 ||FNNFNN;;L
 	
 {{	  \
 	
 $$"$-H--'+++4v=K--'+++4v=KKK12E

Cc"E
c'C
++cl
*Cll5A:s2Gll5B;3G

CF
F{{3T**	e	zz#D)) 
r@   c                   US;  a  [        SU S35      eUS:  a  [        S5      e[        5       (       d0  [        U SSS/S	5        [        US
SS/S	5        [        USSS/S	5        U R                  UR                  s=:X  a  UR                  :X  d  O  [        S5      eUb  UO[        R
                  R                  S5      nU" X5      nU" X5      n	U(       a  U" X5      n
[        R                  " X5      n	[        U[        R                  R                  5      (       d  [        R                  " US:  5      (       aG  [        U	[        R                  R                  5      (       d)  [        R                  " U	S:  5      (       d  [        S5      e[        R                  " X-
  U-   SS9nUS:X  a  [        R                  " XS9$ US:X  a  [        R                  " XS9$ US:X  a  U$ g)a  
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 `input`, `positive` and `negative` (i.e., `input`, `positive examples` and `negative
examples` respectively). The shapes of all input tensors should be
:math:`(N, D)`.

The loss function for each sample in the mini-batch is:

.. math::
    L(input, pos, neg) = \max \{d(input_i, pos_i) - d(input_i, neg_i) + {\rm margin}, 0\}


where the default distance function

.. math::
    d(x_i, y_i) = \left\lVert {\bf x}_i - {\bf y}_i \right\rVert_p

or user can defined their own distance functions. `margin` is a nonnegative margin representing the minimum difference
between the positive and negative distances that is required for the loss to be 0. If `swap` is true, it will compare distance of (input, negative) with
distance of (negative, positive) and change it to the smaller one. For more details see http://www.bmva.org/bmvc/2016/papers/paper119/paper119.pdf.

Parameters:

    input (Tensor):Input tensor, the data type is float32 or float64.
        the shape is [N, \*], N is batch size and `\*` means any number of additional dimensions, available dtype is float32, float64.

    positive (Tensor):Positive tensor, the data type is float32 or float64.
        The shape of label is the same as the shape of input.

    negative (Tensor):Negative tensor, the data type is float32 or float64.
        The shape of label is the same as the shape of input.

    distance_function (callable|None, optional): Quantifies the distance between two tensors. if not specified, 2 norm functions will be used.

    margin (float, optional): A nonnegative margin representing the minimum difference
        between the positive and negative distances required for the loss to be 0. Default value is :math:`1`.

    swap (bool, optional):The distance swap changes the negative distance to the swap distance (distance between positive samples
            and negative samples) if swap distance smaller than negative distance. Default: ``False``.

    reduction (str, optional):Indicate how to average the loss by batch_size.
        the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
        If :attr:`reduction` is ``'none'``, the unreduced loss is returned;
        If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
        If :attr:`reduction` is ``'sum'``, the summed loss is returned.
        Default: ``'mean'``
    name (str|None, optional): Name for the operation (optional, default is None).
        For more information, please refer to :ref:`api_guide_Name`.

Returns:
    Output: Tensor. The tensor variable storing the triplet_margin_with_distance_loss of input and positive and negative.

Examples:
    .. code-block:: python

        >>> import paddle
        >>> import paddle.nn.functional as F

        >>> input = paddle.to_tensor([[1, 5, 3], [0, 3, 2], [1, 4, 1]], dtype=paddle.float32)
        >>> positive = paddle.to_tensor([[5, 1, 2], [3, 2, 1], [3, -1, 1]], dtype=paddle.float32)
        >>> negative = paddle.to_tensor([[2, 1, -3], [1, 1, -1], [4, -2, 1]], dtype=paddle.float32)
        >>> loss = F.triplet_margin_with_distance_loss(input, positive, negative, margin=1.0, reduction='none')
        >>> print(loss)
        Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True,
               [0.        , 0.57496595, 0.        ])

        >>> loss = F.triplet_margin_with_distance_loss(input, positive, negative, margin=1.0, reduction='mean')
        >>> print(loss)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               0.19165532)

r   zc'reduction' in 'triplet_margin_with_distance_loss' should be 'sum', 'mean' or 'none', but received r$   r   RThe margin between positive samples and negative samples should be greater than 0.r7   r+   r,   !triplet_margin_with_distance_lossrm   negativeAinput's shape must equal to positive's shape and negative's shapeNr#   znThe positive distance or negative distance should be greater than 0, The distance functions should be checked.r   r  r   r   r   r   )r`   r	   r   r0   r*   r2   PairwiseDistanceminimumr   r   r   allr  r   r   )r7   rm   r  distance_functionr   swapr   r9   positive_distnegative_dist	swap_distrP   s               r>   r  r    s   h //%;a)
 	

 z`
 	
  	"/		
 	!	"/		
 	!	"/		
 KK8>>;X^^;O
 	
 ( 	YY''*  &e6M%e6M%h9	}@ }fjj&6&677

=A-..}fjj&6&677

=A-..8
 	

 ;;}4v=3GDF{{4++	e	zz$**	f	 
r@   c	                   US;  a  [        SU S35      eUS:  a  [        S5      e[        5       (       d0  [        U SSS/S	5        [        US
SS/S	5        [        USSS/S	5        U R                  UR                  s=:X  a  UR                  :X  d  O  [        S5      e[        R
                  R                  XES9n	U	" X5      n
U	" X5      nU(       a  U	" X5      n[        R                  " X5      n[        R                  " X-
  U-   SS9nUS:X  a  [        R                  " XS9$ US:X  a  [        R                  " XS9$ US:X  a  U$ g)a  
    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 `input`, `positive` and `negative` (i.e., `input`, `positive examples` and `negative
    examples` respectively). The shapes of all input tensors should be
    :math:`(N, *)`.

    The loss function for each sample in the mini-batch is:

    .. math::
        L(input, pos, neg) = \max \{d(input_i, pos_i) - d(input_i, neg_i) + {\rm margin}, 0\}


    where

    .. math::
        d(x_i, y_i) = \left\lVert {\bf x}_i - {\bf y}_i \right\rVert_p

Parameters:
    input (Tensor): Input tensor, the data type is float32 or float64.
        the shape is [N, \*], N is batch size and `\*` means any number of additional dimensions, available dtype is float32, float64.

    positive (Tensor): Positive tensor, the data type is float32 or float64.
        The shape of label is the same as the shape of input.

    negative (Tensor): Negative tensor, the data type is float32 or float64.
        The shape of label is the same as the shape of input.

    margin (float, optional): Default: :math:`1`.

    p (float, optional): The norm degree for pairwise distance. Default: :math:`2.0`.

    epsilon (float, optional): Add small value to avoid division by zero,
        default value is 1e-6.

    swap (bool, optional): The distance swap change the negative distance to the distance between
        positive sample and negative sample. For more details, see `Learning shallow convolutional feature descriptors with triplet losses`.
        Default: ``False``.


    reduction (str, optional):Indicate how to average the loss by batch_size.
        the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
        If :attr:`reduction` is ``'none'``, the unreduced loss is returned;
        If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
        If :attr:`reduction` is ``'sum'``, the summed loss is returned.
        Default: ``'mean'``

    name (str|None, optional): Name for the operation (optional, default is None).
        For more information, please refer to :ref:`api_guide_Name`.

Returns:
    Output: Tensor. The tensor variable storing the triplet_margin_loss of input and positive and negative.

Examples:
    .. code-block:: python

        >>> import paddle
        >>> import paddle.nn.functional as F

        >>> input = paddle.to_tensor([[1, 5, 3], [0, 3, 2], [1, 4, 1]], dtype=paddle.float32)
        >>> positive = paddle.to_tensor([[5, 1, 2], [3, 2, 1], [3, -1, 1]], dtype=paddle.float32)
        >>> negative = paddle.to_tensor([[2, 1, -3], [1, 1, -1], [4, -2, 1]], dtype=paddle.float32)
        >>> loss = F.triplet_margin_loss(input, positive, negative, margin=1.0, reduction='none')
        >>> print(loss)
        Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True,
               [0.        , 0.57496595, 0.        ])

        >>> loss = F.triplet_margin_loss(input, positive, negative, margin=1.0, reduction='mean')
        >>> print(loss)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               0.19165532)

r   zU'reduction' in 'triplet_margin_loss' should be 'sum', 'mean' or 'none', but received r$   r   r  r7   r+   r,   triplet_margin_lossrm   r  r  rY  r   r  r   r   r   r   N)r`   r	   r   r0   r*   r2   r  r  r  r   r   )r7   rm   r  r   pr8   r  r   r9   r  r  r  r  rP   s                 r>   r  r    se   j //%;a)
 	
 z`
 	
  7Y	24I	
 	!j9i"8:O	
 	!j9i"8:O	
 KK8>>;X^^;O
 	
 		2212F%e6M%e6M%h9	}@;;}4v=3GDF{{4++	e	zz$**	f	 
r@   c           
        US;  a  [        SU S35      e[        5       (       d   [        U SSS/S5        [        USS	S
/S5        U R                  S   UR                  S   :X  d,  [        SU R                  S    SUR                  S    S35      eUR	                  S5      n[
        R                  " X5      nUGb  [        5       (       d  [        USSS/S5        U R                  S   UR                  S   :X  d+  [        SUR                  S    SU R                  S    35      e[
        R                  " XASS9R	                  S5      n[
        R                  " U[
        R                  " [
        R                  " X7-
  U -   SS9U5      -  SS9XCU-  [
        R                  " U 5      S   -  -  R                  5       -
  nOa[
        R                  " [
        R                  " [
        R                  " X7-
  U -   SS9U5      SS9X2-  [
        R                  " U 5      S   -  -
  nUS:X  a  [
        R                  " XS9$ US:X  a  [
        R                  " XS9$ US:X  a  U$ g)a	  
    Measures a multi-class classification hinge loss between input :math:`input` and label :math:`label`:

    For i-th mini-batch sample, the loss in terms of the 1D input :math:`input_i` and scalar
    output :math:`label_i` is:

    .. math::
        \text{loss}(input_i, label_i) = \frac{\sum_{j} \max(0, \text{margin} - input_i[label_i] + input_i[j])^p}{\text{C}}

    where :math:`0 \leq j \leq \text{C}-1`, :math:`0 \leq i \leq \text{N}-1` and :math:`j \neq label_i`.

    Optionally, you can give non-equal weighting on the classes by passing
    a 1D :attr:`weight` tensor into the constructor.

    The loss function for i-th sample then becomes:

    .. math::
        \text{loss}(input_i, label_i) = \frac{\sum_{j} \max(0, weight[label_i] * (\text{margin} - input_i[label_i] + input_i[j]))^p}{\text{C}}


Parameters:
    input (Tensor): Input tensor, the data type is float32 or float64. Shape is (N, C), where C is number of classes.

    label (Tensor): Label tensor, the data type is int32 or int64. The shape of label is (N,)

    p (int, optional): The power num. Default: :math:`1`.

    margin (float, optional): Default: :math:`1`.

    weight (Tensor|None, optional): a manual rescaling weight given to each class.
            If given, has to be a Tensor of shape (C,) and the data type is float32, float64.
            Default is ``'None'`` .


    reduction (str, optional):Indicate how to calculate the loss by batch_size.
        the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
        If :attr:`reduction` is ``'none'``, the unreduced loss is returned;
        If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
        If :attr:`reduction` is ``'sum'``, the summed loss is returned.
        Default: ``'mean'``

    name (str|None, optional): Name for the operation (optional, default is None).
        For more information, please refer to :ref:`api_guide_Name`.

Returns:
    Output: Tensor. The tensor variable storing the multi_margin_loss of input and label.

Examples:
    .. code-block:: python

        >>> import paddle
        >>> import paddle.nn.functional as F

        >>> input = paddle.to_tensor([[1, 5, 3], [0, 3, 2], [1, 4, 1]], dtype=paddle.float32)
        >>> label = paddle.to_tensor([1, 2, 1], dtype=paddle.int32)
        >>> loss = F.multi_margin_loss(input, label, margin=1.0, reduction='none')
        >>> print(loss)
        Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True,
               [0.        , 0.66666663, 0.        ])

r   zS'reduction' in 'multi_margin_loss' should be 'sum', 'mean' or 'none', but received r$   r7   r+   r,   multi_margin_lossr!   r-   r.   r   zXThe label's shape[0] should be equal to input's shape[0], but received input's shape[0] z and label's shape[0]:z. )r%   r&   Nr   r&   zYThe weight's shape[0] should be equal to input's shape[1]but received weight's shape[0]: z and input's shape[1]: r'   r   r  r   r   r   r   )r`   r	   r   r0   r   r*   index_samplegatherr   rv  r  r1   r   )	r7   r!   r  r   r   r   r9   r  rP   s	            r>   r  r    s   L //%;a)
 	

  7Y	24G	
 	!7Wg.0C	
 KKNekk!n,--2[[^,<<RSXS^S^_`SaRbbdf
 	
 MM'"E&&u4L  $9i"8:M A&,,q/1339<<?2CCZ[`[f[fgh[iZjl  v15==gFKK**KK!6!>SI
  V\\%%8%;;<EEGH 	 KK

KK 5 =3G 	 i&,,u-a001 	 F{{4++	e	zz$**	f	 
r@   c                x   US;  a  [        SU S35      e[        5       (       d   [        U SSS/S5        [        USS	S
/S5        U R                  5       S:w  a  [        SU R                  5        S35      eUR                  5       S:w  a  [        SUR                  5        S35      eU R                  u  pE[
        R                  " 5       (       a  UR                  5       S:  al  [
        R                  " U5      R                  5       n[
        R                  " U5      R                  5       nUS:  a  [        S5      eXu:  a  [        SU 35      eUS:g  R                  S	5      nXR                  SS9-  n[
        R                  " U5      u  pXU
4   n[
        R                  " XE/SS9nSXU4'   X	U4   R                  S5      nSU-
  X	   -   n[
        R                  " X   U[
        R                  " U5      5      n[
        R                   " U[
        R                  " U5      5      n[
        R"                  " [
        R$                  " U/U R&                  S9U	R                  S5      UR)                  SS95      nUU-  nUS:X  a  [
        R*                  " UUS9$ US:X  a  [
        R(                  " UUS9$ US:X  a  U$ g)a>	  Measures a multi-class multi-classification hinge loss (margin-based loss) between input :math:`input` and label :math:`label`:

For i-th mini-batch sample, the loss in terms of the 2D input :math:`input_i` and 2D label :math:`label_i` is:

.. math::
    \text{loss}(input_i, label_i) = \frac{\sum_{j \in \text{valid_labels}} \sum_{k \neq \text{valid_labels}} \max(0, 1 - (input_i[\text{valid_labels}[j]] - input_i[k]))}{C}

where :math:`C` is the number of classes, :math:`\text{valid_labels}` contains all non-negative label indices
for sample :math:`i` (stopping at the first -1 encountered), and :math:`k` ranges over all class indices
except those in :math:`\text{valid_labels}`.

The criterion only considers the first non-negative label values, allowing different samples to have variable numbers of target classes.

Parameters:
    input (Tensor): Input tensor, the data type is float32 or float64. Shape is (N, C), where C is number of classes.
    label (Tensor): Label tensor, the data type is int32 or int64. Shape is (N, C), same shape as input.
        Label values should be class indices (non-negative values) and -1 values.
        The -1 values are ignored and stop processing for each sample.
    reduction (str, optional): Indicate how to calculate the loss by batch_size,
        the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
        If :attr:`reduction` is ``'none'``, the unreduced loss is returned;
        If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
        If :attr:`reduction` is ``'sum'``, the summed loss is returned.
        Default: ``'mean'``
    name (str|None, optional): Name for the operation (optional, default is None).
        For more information, please refer to :ref:`api_guide_Name`.

Returns:
    Tensor, The tensor variable storing the multi_label_margin_loss of input and label.

Examples:
    .. code-block:: python

        >>> import paddle
        >>> import paddle.nn.functional as F

        >>> input = paddle.to_tensor([[0.1, 0.2, 0.4, 0.8], [0.2, 0.5, 0.3, 0.1]], dtype='float32')
        >>> label = paddle.to_tensor([[3, 0, -1, -1], [0, 2, -1, -1]], dtype='int64')

        >>> loss = F.multi_label_margin_loss(input, label, reduction='mean')
        >>> print(loss)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               0.94999999)
r   zY'reduction' in 'multi_label_margin_loss' should be 'sum', 'mean' or 'none', but received r$   r7   r+   r,   multi_label_margin_lossr!   r-   r.   r#   z"Expected 2D input tensor, but got Dz"Expected 2D label tensor, but got r   r%   zlabel values should be >= -1zlabel values should be < r&   )r   boolrC   Fr'   r   r   r   r   N)r`   r	   r   r   r0   r*   numelr  itemmaxr  cumprodr  onesrI  r  maximumscatter_nd_addr  r)   r   r   )r7   r!   r   r9   NCmin_valmax_val
valid_maskrow_idscol_idstargets_flatinvalid_maskinput_targetr   relu_marginlossess                    r>   r  r    s   d //%;a)
 	

  7Y	24M	
 	!7Wg.0I	
 yy{a=eiik]!LMMyy{a=eiik]!LMM;;DAEKKMA$5**U#((***U#((*R<;<<<8<== 2+##G,J00Q077J||J/G')*L;;vV4L*/L,&' ,./99"=L.F\\vv'8'8'@F ..):):6)BCK""aS," 	 	
F aKFF{{6--	e	zz&t,,	f	 
r@   c                2   US;  a  [        SU S35      e[        5       (       dH  [        R                  R	                  U SSS/S5        [        R                  R	                  US/ S	QS5        U R
                  UR
                  :X  d  [        S
5      e[        R                  " XR                  5      n[        R                  " S[        R                  " U* U -  5      -   5      nUS:X  a  [        R                  " XCS9$ US:X  a  [        R                  " XCS9$ U$ )a
  

The API measures the soft margin loss between input predictions ``input``
and target labels ``label`` . It can be described as:

.. math::
    Out = log(1 + exp((-label * input)))

Parameters:

    input (Tensor): The input predications tensor with shape: ``[N, *]``,
        N is batch_size, `*` means any number of additional dimensions. The ``input`` ranges from -inf to inf.
        Available dtype is float32, float64.

    label (Tensor): The target labels tensor with the same shape as
        ``input``. The target labels which values should be numbers -1 or 1.
        Available dtype is int32, int64, float32, float64.

    reduction (str, optional): Indicate how to average the loss by batch_size,
        the candidates are ``'none'`` | ``'mean'`` | ``'sum'``.
        If :attr:`reduction` is ``'none'``, the unreduced loss is returned;
        If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
        If :attr:`reduction` is ``'sum'``, the summed loss is returned.
        Default is ``'mean'``.

    name (str|None, optional): Name for the operation (optional, default is None).
        For more information, please refer to :ref:`api_guide_Name`.

Returns:

    Output (Tensor): If ``reduction`` is ``'none'``, the shape of output is same as ``input`` , else the shape of output is [].

Examples:
    .. code-block:: python

        >>> import paddle
        >>> paddle.seed(2023)

        >>> input = paddle.to_tensor([[0.5, 0.6, 0.7],[0.3, 0.5, 0.2]], 'float32')
        >>> label = paddle.to_tensor([[1.0, -1.0, 1.0],[-1.0, 1.0, 1.0]], 'float32')
        >>> output = paddle.nn.functional.soft_margin_loss(input, label)
        >>> print(output)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               0.64022040)

        >>> input = paddle.uniform(shape=(5, 5), dtype="float32", min=0.1, max=0.8)
        >>> label = paddle.randint(0, 2, shape=(5, 5), dtype="int64")
        >>> label[label==0] = -1

        >>> output = paddle.nn.functional.soft_margin_loss(input, label, reduction='none')
        >>> print(output)
        Tensor(shape=[5, 5], dtype=float32, place=Place(cpu), stop_gradient=True,
               [[1.10725629, 0.48778144, 0.56217247, 1.12581408, 0.51430041],
                [0.90375793, 0.37761253, 0.43007556, 0.95089805, 0.43288314],
                [1.16043591, 0.63015938, 0.51362717, 0.43617544, 0.57783306],
                [0.81927848, 0.52558368, 0.59713912, 0.83100700, 0.50811619],
                [0.82684207, 1.02064908, 0.50296998, 1.13461733, 0.93222517]])

r   z]The value of 'reduction' in soft_margin_loss should be 'sum', 'mean' or 'none', but received r   r7   r+   r,   soft_margin_lossr!   )r-   r.   r+   r,   r   r&   r   r   r   )r`   r	   r   r  r   r0   r*   r  r)   r  r   r   r   )r7   r!   r   r9   r   s        r>   r  r    s   B //..7[8OQ
 	

 117Y	24F	
 	114		
 KK5;;&DEEKK{{+E
**QUFUN33
4CEzz#))	f	{{3**
r@   c                   UR                   U R                   :w  at  U R                   SS UR                   :X  a  [        R                  " US5      nO?U R                   SS UR                   SS :X  a  UR                   S   S:X  a  O[        S5      eUS:w  a  US:w  a  US:w  a  [        US-   5      e[	        U S	S
S/S5        [	        USS
S/S5        [	        USS
S/S5        [        5       (       d'  [        R                  " US:  5      n[        Xr/S5        OU R                  [        R                  [        R                  4;  a  [        S5      eUR                  [        R                  [        R                  4;  a  [        S5      eUR                  [        R                  [        R                  4;  a  [        S5      e[        R                  " US:  5      (       a  [        S5      eUR                  5       n[        R                  " 5          [        R                  " X$S9nSSS5        S[        R                  " U5      [        R                   " X-
  5      U-  -   -  nU(       a-  US["        R                  " S["        R$                  -  5      -  -  nUS:X  a  [        R&                  " XS9$ US:X  a  [        R(                  " XS9$ US:X  a  U$ g! , (       d  f       N= f)a  Gaussian negative log likelihood loss.

Gaussian negative log likelihood loss among ``input``, ``variance`` and
``label``. Note that the ``label`` is treated as samples from Gaussian distributions.
This function is used to train a neural network predicts
the ``input`` and ``variance`` of a gaussian distribution that ``label`` are supposed to
be coming from. This means ``input`` and ``variance`` should be functions(the neural network) of some inputs.

For a ``label`` having Gaussian distribution with ``input`` and ``variance`` predicted by neural network
the loss is calculated as follows:

.. math::
    \text{loss} = \frac{1}{2}\left(\log\left(\text{max}\left(\text{var},
    \ \text{epsilon}\right)\right) + \frac{\left(\text{input} - \text{label}\right)^2}
    {\text{max}\left(\text{var}, \ \text{epsilon}\right)}\right) + \text{const.}

where :attr:`epsilon` is used for stability. By default, the constant term of
the loss function is omitted unless :attr:`full` is ``True``. If ``variance`` is not the same
size as ``input`` (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.

Args:
    input (Tensor): input tensor, :math:`(N, *)` or :math:`(*)` where :math:`*` means any number of additional
        dimensions. Expectation of the Gaussian distribution, available dtype is float32, float64.
    label (Tensor): target label tensor, :math:`(N, *)` or :math:`(*)`, same shape as the input, or same shape as the input
        but with one dimension equal to 1 (to allow for broadcasting). Sample from the Gaussian distribution, available dtype is float32, float64.
    variance (Tensor): tensor of positive variance(s), :math:`(N, *)` or :math:`(*)`, same shape as the input, or same shape as the input but
        with one dimension equal to 1, or same shape as the input but with one fewer
        dimension (to allow for broadcasting). One for each of the expectations
        in the input (heteroscedastic), or a single one (homoscedastic), available dtype is float32, float64.
    full (bool, optional): include the constant term in the loss
        calculation. Default: ``False``.
    epsilon (float, optional): value used to clamp ``variance`` (see note below), for
        stability. Default: 1e-6.
    reduction (str, optional): specifies the reduction to apply to the
        output:``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction
        will be applied, ``'mean'``: the output is the average of all batch
        member losses, ``'sum'``: the output is the sum of all batch member
        losses. Default: ``'mean'``.
    name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.

Returns:

    output (Tensor): If ``reduction`` is ``'none'``, the shape of output is same as ``input`` , else the shape of output is [].

Examples::
    .. code-block:: python

        >>> import paddle
        >>> import paddle.nn.functional as F
        >>> paddle.seed(2023)

        >>> input = paddle.randn([5, 2], dtype=paddle.float32)
        >>> label = paddle.randn([5, 2], dtype=paddle.float32)
        >>> variance = paddle.ones([5, 2], dtype=paddle.float32)

        >>> loss = F.gaussian_nll_loss(input, label, variance, reduction='none')
        >>> print(loss)
        Tensor(shape=[5, 2], dtype=float32, place=Place(cpu), stop_gradient=True,
               [[0.21808575, 1.43013096],
                [1.05245590, 0.00394560],
                [1.20861185, 0.00000062],
                [0.56946373, 0.73300570],
                [0.37142906, 0.12038800]])

        >>> loss = F.gaussian_nll_loss(input, label, variance, reduction='mean')
        >>> print(loss)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
               0.57075173)

Note:
    The clamping of ``variance`` is ignored with respect to autograd, and so the
    gradients are unaffected by it.
Nr%   r&   zvariance is of incorrect shaper   r   r   z is not validInputr+   r,   gaussian_nll_lossr^   Variancer      r  z<The data type of label Variable must be 'float32', 'float64'z?The data type of variance Variable must be 'float32', 'float64'z#variance has negative entry/entriesr  r   r#   r   )r0   r*   rI  r`   r   r	   r  r
   r)   r+   r,   anycloneno_gradr  r  r{   r  r  r   r   )	r7   r!   variancer   r8   r   r9   r  rP   s	            r>   r  r  b  s   n ~~$
 ;;sx~~-''"5H
 KKs 33r8Ja8O =>> FyF2yE7I_455	I	 	I	 	I	 JJx!|,	y*a(;;v~~v~~>>P  ;;NNNN
 
 N  >>&..&..!AAQ  ::hl##BCC ~~H		;;x5 
 

8v}}U];hFFD dhhq477{+++F{{4++	e	zz$**	f	 
 
	s   K
Kc                	   UR                  5       nUS:X  ak  U R                  S   UR                  S   :w  a  UR                  S   S:w  a  [        S5      eU R                  5       S:w  a  [        SU R                   35      eO>US:X  a-  U R                  5       S:w  a  [        SU R                   35      eO[        S5      eUS:  nU(       a  U OU R                  S5      n U(       a  UOUR                  S5      nSn	UR                  S   n
[        R
                  " U
/U R                  S9n[        R                  " U
/UR                  S9nS/UQn[        [        U5      S-
  5       GH  nX   nXS-      nX:  UU:  -  nUR                  5       R                  5       nUR                  5       S:X  a  UR                  S5        UR                  5       S:X  a  Mr  US:X  aD  [        R                  " UR                  S5      UR                  U5      UR                  5      nUnGOCUU   U-
  nU R!                  USS	9n[        R"                  R$                  R'                  UX>S-
     S   S
9n[        R"                  R$                  R'                  UX>S-
     S   S
9nUS   U-   S-
  n[        R(                  " UUSU5      n[        R"                  R$                  R+                  USS	9n[        R,                  " UUR                  S5      SS	9n[        R                  " UR                  S5      UR                  S5      UR                  5      nUUS:H  R/                  S5      -  U-   nU	UR                  5       -  n	GM     X:w  aJ  [        SUR1                  5       R3                  5        SUR5                  5       R3                  5        S35      e[        R"                  R$                  R'                  XUS9n[        R"                  R$                  R+                  USS	9nUR6                  S:w  a6  U[        R,                  " UUR                  S5      SS	9R                  5       -  nU* R9                  5       nU(       d  UR                  S5      nUU4$ )a  Compute adaptive logsoftmax result and negative log likelihood between ``input`` and ``label``.
Parameter ``head``, ``tail_weights``, ``cutoffs`` are inner members of AdaptiveLogSoftmaxWithLoss
Please refer to :ref:`api_paddle_nn_AdaptiveLogSoftmaxWithLoss`.

Args:
    input (Tensor): Input tensor, the data type should be float32 or float64.
    label (Tensor): Label tensor, the data type should be float32 or float64.
    head_weight (Tensor): weight tensor for linear computation, the data type should be float32 or float64, the shape should be ``[input.shape[1], shortlist_size + n_clusters]``, where ``shortlist_size`` is the first element in the cutoffs list, and ``n_clusters`` is the length of the cutoffs list minus 1.
    tail_weights (list|tuple): weight tensor list or tuple for linear computation, the data type should be float32 or float64. The number of elements in the tail_weights depends on the value of the n_clusters, and each element contains the weights of two linear layers, their dimensions are ``[input.shape[1], hsz]`` and ``[hsz, osz]``, where ``hsz`` is the number of input features in_features divided by div_value to the power ``(i + 1)``, where i is the cyclic variable, from ``0`` to ``n_clusters - 1``, and ``osz`` is the ``(i + 1)`` The difference between the cutoff and the ith cutoff.
    cutoffs (Sequence): Cutoffs used to assign targets to their buckets.
    head_bias (Tensor|None, optional): bias tensor for linear computation, the data type should be float32 or float64. Default: ``None``.
    name (str|None, optional): Name for the operation (optional, default is ``None``). For more information, please refer to :ref:`api_guide_Name`.

Returns:
    - output (Tensor). The tensor storing adaptive logsoftmax result, the shape of output is ``[N]``
    - loss (Tensor). The tensor variable storing the adaptive_log_softmax_loss of input and label.

Examples:
    .. code-block:: python

        >>> from typing import List
        >>> import paddle
        >>> import paddle.nn.functional as F

        >>> paddle.seed(2024)
        >>> input = paddle.randn([3, 5], dtype=paddle.float32)
        >>> head_weight = paddle.randn([5, 3], dtype=paddle.float32)
        >>> head_bias = paddle.randn([3], dtype=paddle.float32)
        >>> tail_weights: List[List[paddle.Tensor]] = [[]]
        >>> tail_weights[0].append(paddle.randn([5, 2], dtype=paddle.float32))
        >>> tail_weights[0].append(paddle.randn([2, 1], dtype=paddle.float32))
        >>> out, loss = F.adaptive_log_softmax_with_loss(
        ...     input,
        ...     paddle.full([3], 1, dtype='int64'),
        ...     head_weight,
        ...     tail_weights,
        ...     cutoffs=[2],
        ...     head_bias=head_bias
        ... )
        >>> print(out)
        Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True,
        [-0.99842924, -2.27753878, -0.16740258])
        >>> print(loss)
        Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True,
        1.14779019)
r&   r   zAInput and label should have the same size in the batch dimension.r#   zE1D label tensor expects 2D input tensors, but found inputs with size zE0D label tensor expects 1D input tensors, but found inputs with size z90D or 1D label tensor expected, multi-label not supportedrC   r'   )r   r   r+   zClabel values should be in [0, n_classes - 1], but values in range [z, z] were found. )r   r   r   )r   r0   r`   rI  r*   r  r)   emptyr6   r/   nonzeror1   
unsqueeze_r  
scatter_ndmasked_selectindex_selectr2   r3   linear
index_filllog_softmaxtake_along_axisrz   r  r  r  rv   r   )r7   r!   head_weighttail_weightscutoffs	head_biasr9   
target_dim
is_batched	used_rowsrf   outputgather_indscutoff_valuesilow_idxhigh_idx
label_maskrow_indicesscatter_outputrelative_labelinput_subsetcluster_outputcluster_indexcluster_logproblocal_logprobhead_outputhead_logprobrP   s                                r>   adaptive_log_softmax_with_lossr    s   n JQ;;q>U[[^+A!0C*  99;!..3kk]<  
 
q99;!..3kk]<   G
 	
 aJEU__Q%7EEU__Q%7EIQJ\\:,ekk:F,,
|5;;?KMMM3}%)*" Q'&58+;<
 ((*224??!""1%!#6#..%%a(##J/!!N
 )K":.8N --k-BL#YY1188|E':1'= 9 N $YY1188 !e)<Q)? 9 N $AJNQ.M ++[!]K %ii22>>Q ? O #22!9!9!!<1M $..%%a(-*?*?*BFLLN .A-55i@@ ! 
 	[&&((	i +l $$)IIK$4$4$6#7r%))+:J:J:L9M N
 	
 ))&&--
) . K 99''33Ka3HL1&((+//2

')	 G>>D"4<r@   )gh㈵>N)
r7   r   r!   r   r8   floatr9   
str | Nonereturnr   )g-C6?N)Fr    TFr%   )rb   r   r!   r   rV   r  rW   intrX   r  rc   r  r(   r  r  r   )gMb`?)
rk   r   rm   r   rn   r   r}   r  r  r   )r7   r   r!   r   r  r   )TNNN)r7   r   r!   r   r   r  r   zSequence[int] | Noner   Tensor | Noner   r  r  tuple[Tensor, Tensor])Nr   N)r7   r   r!   r   r   r  r   r   r9   r  r  r   )Nr   NN)r   r   r!   r   r   r  r   r   r   r  r9   r  r  r   )NNNFN)r7   r   r!   r   r   r  r   r   r   r  r   r  r   r  r   r  r9   r  r  r   )r   r   TN)r7   r   r!   r   r   r   r   r  r   r  r9   r  r  r   )r   r   N)r7   r   r   r   r!   r   r   r  r   r   r9   r  r  r   )r   N)
r7   r   r!   r   r   r   r9   r  r  r   )Nr    r   N)r7   r   r!   r   r   r  rW   r  r   r   r9   r  r  r   )TFg:0yE>r   N)r7   r   r!   r   r  r  r   r  r8   r  r   r   r9   r  r  r   )r   FN)r7   r   r!   r   r   r   r  r  r9   r  r  r   )r   r   FF)r!  r   rn   r   r"  r   r#  r   r  r  r   r   r  r  r$  r  r  r   )r   r.  r   N)r7   r   r!   r   r"  r   r#  r   r  r  r,  r  r   r   r9   r  r  r   ).......)rb   r   r!   r   r5  r  r6  r  r7  r  r8  r  rc   Literal[True]r   _ReduceMode | Noner  r  )rb   r   r!   r   r5  r  r6  r  r7  r  r8  r  rc   Literal[False]r   r  r  r   )rb   r   r!   r   r5  r  r6  r  r7  r  r8  r  rc   r  r   r  r  Tensor | tuple[Tensor, Tensor])r   r   r   g      P@NFr   ).....)rb   r   r!   r   rV   r  rW   r  rX   r  rc   r  r(   r  r  r  )rb   r   r!   r   rV   r  rW   r  rX   r  rc   r  r(   r  r  r   )rb   r   r!   r   rV   r  rW   r  rX   r  rc   r  r(   r  r  r  )Nr    r   Fr%   Tr   N)r7   r   r!   r   r   r  rW   r  r   r   rV   r  r(   r  rb  r  rf  r  r9   r  r  r   )Nro   g       @r   N)r   r   r!   r   rs  r  rx  r  ry  r  r   r   r9   r  r  r   )r   r   N)r7   r   r!   r   r   r  r   r   r9   r  r  r   )r   r   N)r  r   r  r   r!   r   r   r  r   r   r9   r  r  r   )Nr   Fr   N)r7   r   rm   r   r  r   r  z)Callable[[Tensor, Tensor], Tensor] | Noner   r  r  r  r   r   r9   r  r  r   )r   r#   ư>Fr   N)r7   r   rm   r   r  r   r   r  r  r  r8   r  r  r  r   r   r9   r  r  r   )r&   r   Nr   N)r7   r   r!   r   r  r  r   r  r   r  r   r   r9   r  r  r   )Fr  r   N)r7   r   r!   r   r  r   r   r  r8   r  r   r   r9   r  r  r   )NN)r7   r   r!   r   r  r   r  zSequence[Sequence[Tensor]]r  zSequence[int | Tensor]r  r  r9   r  r  r  )H
__future__r   r  typingr   r   r   r*   r   r   r	   paddle.static.nn.control_flowr
   paddle.utilsr   paddle.utils.decorator_utilsr   base.data_feederr   r   base.frameworkr   r   r   r   base.layer_helperr   common_ops_importr   tensor.manipulationr   collections.abcr   r   r   r   r   __annotations____all__r   r?   rB   ri   rl   r   r   r   r   r   r   r   r   r   r   r  r  r'  r0  r:  rY   r   rt  r  r  r  r  r  r  r  r  r  r  r3  r@   r>   <module>r     sd   #  3 3  0 0 0 # < D  - ) *(*$%:;K;
 	H#H#H# H# 	H#
 H#\ 	999 9 	9
 9~  $ ZZZ Z 	Z
 Z Z Z Z| GLRR$R.4R>CRRj<D +/"&"&o+o+o+ o+ )	o+
  o+  o+ o+j !#CCC C 	C
 C CR !# $www w 	w
 w w w~  $#nnn n 	n
 n n n n n nh $kkk k 	k
 k k kd #vvv v 	v
 v v vx $	gLgLgL gL 	gL
 gLZ !#}}} } 	}
 } } }F #rrr r 	r
 r r r rp $OOO O 	O
 O Oj $	M
M
M
 M
 	M

 M
j #\\\ \ 	\
 \ \ \ \ \H "#||| | 	|
 | | | | |~ 
 
$'$'
 
 
  
  	
 
 
  
  "
  "
  
  

  
 
%($'


 
 	

 
 
 #
 "
 
 

 
 
$'
)
)
) 
) 	
)
 
) 
) 
) "
) $
) 

)  

u!p	 
  #$'      	 
   "      
  
  #%(  	
  #   
 
  #))) ) 	)
 ) ) ) $) 
) 
2
	A 	eeP gz*+ !# Z	Z	Z	 Z	 	Z	
 Z	 Z	 Z	 Z	 Z	 Z	 Z	 ,Z	@ !%"nnn n 	n
 n n n nh !#n n n  n  	n 
 n  n h #jjj j 	j
 j jb #u*u*u* u* 	u*
 u* u* u*x DH#WWW W A	W
 W W W W W| #}}} } 	}
 } } } } } }F  #@@@ @ 	@
 @ @ @ @L $	ttt t 	t
 tt $	]]] ] 	]
 ]H #fff f 	f
 f f f f^  $ddd d -	d
 $d d d dr@   