loss.py 161.3 KB
Newer Older
1
# -*- coding: utf-8 -*
2 3 4 5 6 7 8 9 10 11 12 13 14 15
#   Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

16
# TODO: define loss functions of neural network
17 18
import paddle
import paddle.fluid as fluid
19
from paddle import _C_ops, _legacy_C_ops, in_dynamic_mode
20
from paddle.framework import core
21
from paddle.utils import deprecated
22 23

from ...fluid.data_feeder import check_variable_and_dtype
24
from ...fluid.framework import (
25
    _current_expected_place,
26 27
    _in_legacy_dygraph,
    _non_static_mode,
28 29
    _varbase_creator,
    in_dygraph_mode,
30
)
31 32 33 34
from ...fluid.layer_helper import LayerHelper
from ...fluid.layers.nn import _elementwise_op_in_dygraph
from ...static import Variable
from ...tensor.manipulation import reshape
35

36 37
__all__ = []

38 39
kIgnoreIndex = -100

40

41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
def dice_loss(input, label, epsilon=0.00001, name=None):
    r"""

    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 groud 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, 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:
        Tensor, which shape is [1], 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)
    """
    assert input.dtype in (paddle.float32, paddle.float64)
    assert label.dtype in (paddle.int32, paddle.int64)
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
    assert (
        len(input.shape) >= 2
    ), "The rank of input should be greater than or equal to 2."
    assert len(input.shape) == len(label.shape), (
        "The rank of input and label should be equal, "
        "but received input: %d, label: %d."
        % (len(input.shape), len(label.shape))
    )
    assert label.shape[-1] == 1, (
        "The last dimension of label should be 1, "
        "but received %d." % label.shape[-1]
    )
    assert (
        input.shape[:-1] == label.shape[:-1]
    ), "All dimensions should be equal except the last one."
    assert (
        input.numel() > 0 and label.numel() > 0
    ), "Any dimension of input and label cannot be equal to 0."
103 104 105 106 107 108

    label = paddle.squeeze(label, [-1])
    label = paddle.nn.functional.one_hot(label, input.shape[-1])
    reduce_dim = list(range(1, len(input.shape)))
    inse = paddle.sum(input * label, axis=reduce_dim)
    dice_denominator = paddle.sum(input, axis=reduce_dim) + paddle.sum(
109 110
        label, axis=reduce_dim
    )
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
    dice_score = 1 - inse * 2 / (dice_denominator + epsilon)
    return paddle.mean(dice_score)


def log_loss(input, label, epsilon=1e-4, name=None):
    r"""

    **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|list):  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|list):  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): 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)
    """
    if in_dygraph_mode():
153
        return _C_ops.log_loss(input, label, epsilon)
154 155 156 157 158 159 160

    helper = LayerHelper('log_loss', **locals())
    check_variable_and_dtype(input, 'input', ['float32'], 'log_loss')
    check_variable_and_dtype(label, 'label', ['float32'], 'log_loss')

    loss = helper.create_variable_for_type_inference(dtype=input.dtype)

161 162 163 164 165 166
    helper.append_op(
        type='log_loss',
        inputs={'Predicted': [input], 'Labels': [label]},
        outputs={'Loss': [loss]},
        attrs={'epsilon': epsilon},
    )
167 168 169
    return loss


170 171 172 173 174 175 176 177 178
def fluid_softmax_with_cross_entropy(
    logits,
    label,
    soft_label=False,
    ignore_index=-100,
    numeric_stable_mode=True,
    return_softmax=False,
    axis=-1,
):
179 180
    r"""

181 182
    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
183 184 185 186 187 188
    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.

189 190 191
    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
192 193 194 195 196 197 198
    single label.

    The equation is as follows:

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

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

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

    .. math::
204
        \\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
205 206 207 208

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

    .. math::
209 210 211
        \\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)
212 213 214 215 216 217

    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
218 219 220
            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``
221 222 223 224 225
            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 interpretant 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
226
                                      if :attr:`soft_label` is set to :attr:`False`.
227 228 229
                                      Default: kIgnoreIndex(-100).
        numeric_stable_mode (bool, optional): A flag to indicate whether to use a more
                                              numerically stable algorithm. Only valid
230 231 232
                                              when :attr:`soft_label` is :attr:`False`
                                              and GPU is used. When :attr:`soft_label`
                                              is :attr:`True` or CPU is used, the
233 234 235 236 237
                                              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.
238
        axis (int, optional): The index of dimension to perform softmax calculations. It
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
                              should be in range :math:`[-1, rank - 1]`, while :math:`rank`
                              is the rank of input :attr:`logits`. Default: -1.

    Returns:
        ``Tensor`` or Tuple of two ``Tensor`` : Return the cross entropy loss if \
                                                    `return_softmax` is False, otherwise the tuple \
                                                    (loss, softmax), softmax is in the same shape \
                                                    with input logits and cross entropy loss is in \
                                                    the same shape with input logits except shape \
                                                    in dimension :attr:`axis` as 1.

    Examples:
        .. code-block:: python

            import paddle
254 255 256 257 258

            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)
259
            print(out)
260 261
            # Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True,
            #        [1.15328646])
262 263 264
    """
    if _non_static_mode():
        if core.is_compiled_with_npu():
265
            softmax, backprop, loss = _legacy_C_ops.softmax_with_cross_entropy(
266 267 268 269 270 271 272 273 274 275 276
                logits,
                label,
                'soft_label',
                soft_label,
                'ignore_index',
                ignore_index,
                'numeric_stable_mode',
                numeric_stable_mode,
                'axis',
                axis,
            )
277 278
        else:
            if in_dygraph_mode():
279
                softmax, loss = _C_ops.cross_entropy_with_softmax(
280 281 282 283 284 285 286 287
                    logits,
                    label,
                    soft_label,
                    True,
                    numeric_stable_mode,
                    ignore_index,
                    axis,
                )
288
            if _in_legacy_dygraph():
289
                softmax, loss = _legacy_C_ops.softmax_with_cross_entropy(
290 291 292 293 294 295 296 297 298 299 300
                    logits,
                    label,
                    'soft_label',
                    soft_label,
                    'ignore_index',
                    ignore_index,
                    'numeric_stable_mode',
                    numeric_stable_mode,
                    'axis',
                    axis,
                )
301 302 303 304 305 306 307 308 309
        if not return_softmax:
            return loss
        else:
            return loss, softmax

    attrs = {
        'soft_label': soft_label,
        'ignore_index': ignore_index,
        'numeric_stable_mode': numeric_stable_mode,
310
        'axis': axis,
311 312 313 314 315 316 317 318 319
    }
    helper = LayerHelper('softmax_with_cross_entropy', **locals())
    softmax = helper.create_variable_for_type_inference(dtype=logits.dtype)
    loss = helper.create_variable_for_type_inference(dtype=logits.dtype)

    outputs = {'Softmax': softmax, 'Loss': loss}
    if core.is_compiled_with_npu() or core.is_compiled_with_mlu():
        backprop = helper.create_variable_for_type_inference(dtype=logits.dtype)
        outputs['Backprop'] = backprop
320 321 322 323 324 325
    helper.append_op(
        type='softmax_with_cross_entropy',
        inputs={'Logits': logits, 'Label': label},
        outputs=outputs,
        attrs=attrs,
    )
326 327 328 329 330 331 332 333

    if return_softmax:
        return loss, softmax

    return loss


def npair_loss(anchor, positive, labels, l2_reg=0.002):
334 335
    """

336 337 338
    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.
339

340 341
    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>`_
342

343
    Args:
344
      anchor(Tensor): embedding vector for the anchor image. shape=[batch_size, embedding_dims],
345
                        the data type is float32 or float64.
346
      positive(Tensor): embedding vector for the positive image. shape=[batch_size, embedding_dims],
347 348 349 350
                        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(float32): L2 regularization term on embedding vector, default: 0.002.

351

352 353
    Returns:
      A Tensor representing the npair loss, the data type is the same as anchor, the shape is [1].
354

355 356 357
    Examples:

      .. code-block:: python
358

359
          import paddle
360

361
          DATATYPE = "float32"
362

363 364 365
          anchor = paddle.rand(shape=(18, 6), dtype=DATATYPE)
          positive = paddle.rand(shape=(18, 6), dtype=DATATYPE)
          labels = paddle.rand(shape=(18,), dtype=DATATYPE)
366

367 368
          npair_loss = paddle.nn.functional.npair_loss(anchor, positive, labels, l2_reg = 0.002)
          print(npair_loss)
369

370
    """
371 372 373 374 375 376 377 378 379
    check_variable_and_dtype(
        anchor, 'anchor', ['float32', 'float64'], 'npair_loss'
    )
    check_variable_and_dtype(
        positive, 'positive', ['float32', 'float64'], 'positive'
    )
    check_variable_and_dtype(
        labels, 'labels', ['float32', 'float64', 'int64'], 'labels'
    )
380 381 382 383 384 385
    Beta = 0.25
    batch_size = labels.shape[0]

    labels = paddle.reshape(labels, shape=[batch_size, 1])
    labels = paddle.tile(labels, repeat_times=[1, batch_size])

386 387 388
    labels = paddle.equal(labels, paddle.transpose(labels, perm=[1, 0])).astype(
        'float32'
    )
389 390
    labels = labels / paddle.sum(labels, axis=1, keepdim=True)

391 392 393
    l2loss = paddle.mean(paddle.sum(paddle.square(anchor), 1)) + paddle.mean(
        paddle.sum(paddle.square(positive), 1)
    )
394 395
    l2loss = l2loss * Beta * l2_reg

396 397 398 399 400 401
    similarity_matrix = paddle.matmul(
        anchor, positive, transpose_x=False, transpose_y=True
    )
    softmax_ce = fluid_softmax_with_cross_entropy(
        logits=similarity_matrix, label=labels, soft_label=True
    )
402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
    cross_entropy = paddle.sum(labels * softmax_ce, 0)
    celoss = paddle.mean(cross_entropy)

    return l2loss + celoss


def square_error_cost(input, label):
    r"""

    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:
425 426
        Tensor, The tensor storing the element-wise squared error
        difference between input and label.
427 428 429 430 431 432 433 434 435 436 437 438 439

    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)
            # [0.01, 0.01]

    """
440
    if in_dygraph_mode():
441 442
        minus_out = _C_ops.subtract(input, label)
        square_out = _C_ops.square(minus_out)
443 444
        return square_out
    elif _in_legacy_dygraph():
445 446
        minus_out = _legacy_C_ops.elementwise_sub(input, label)
        square_out = _legacy_C_ops.square(minus_out)
447 448
        return square_out

449 450 451 452 453 454
    check_variable_and_dtype(
        input, "input", ['float32', 'float64'], 'square_error_cost'
    )
    check_variable_and_dtype(
        label, "label", ['float32', 'float64'], 'square_error_cost'
    )
455 456
    helper = LayerHelper('square_error_cost', **locals())
    minus_out = helper.create_variable_for_type_inference(dtype=input.dtype)
457 458 459 460 461
    helper.append_op(
        type='elementwise_sub',
        inputs={'X': [input], 'Y': [label]},
        outputs={'Out': [minus_out]},
    )
462 463

    square_out = helper.create_variable_for_type_inference(dtype=input.dtype)
464 465 466
    helper.append_op(
        type='square', inputs={'X': [minus_out]}, outputs={'Out': [square_out]}
    )
467 468 469
    return square_out


470 471 472 473 474 475 476 477
def edit_distance(
    input,
    label,
    normalized=True,
    ignored_tokens=None,
    input_length=None,
    label_length=None,
):
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
    """
    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, default True): Indicated whether to normalize the edit distance.
        ignored_tokens(list<int>, default None): Tokens that will be removed before
                                     calculating edit distance.
        input_length(Tensor): 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): 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:
511 512 513
        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,).
514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551

    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)
            # [[3.]
            #  [2.]
            #  [4.]
            #  [1.]]
            # if set normalized to True
            # [[0.75]
            #  [0.5 ]
            #  [1.  ]
            #  [0.25]
            #
            # print(sequence_num)
            # [4]

    """
    check_variable_and_dtype(input, 'input', ['int64'], 'edit_distance')
    check_variable_and_dtype(label, 'label', ['int64'], 'edit_distance')
    helper = LayerHelper("edit_distance", **locals())

    # remove some tokens from input and labels
    if ignored_tokens is not None and len(ignored_tokens) > 0:
        erased_input = helper.create_variable_for_type_inference(dtype="int64")
        erased_label = helper.create_variable_for_type_inference(dtype="int64")

552 553 554 555 556 557
        helper.append_op(
            type="sequence_erase",
            inputs={"X": [input]},
            outputs={"Out": [erased_input]},
            attrs={"tokens": ignored_tokens},
        )
558 559
        input = erased_input

560 561 562 563 564 565
        helper.append_op(
            type="sequence_erase",
            inputs={"X": [label]},
            outputs={"Out": [erased_label]},
            attrs={"tokens": ignored_tokens},
        )
566 567
        label = erased_label

Z
zhiboniu 已提交
568
    if in_dygraph_mode():
569 570 571
        return _C_ops.edit_distance(
            input, label, input_length, label_length, normalized
        )
Z
zhiboniu 已提交
572

573 574 575 576 577 578 579 580
    this_inputs = {"Hyps": [input], "Refs": [label]}
    if input_length is not None and label_length is not None:
        this_inputs['HypsLength'] = [input_length]
        this_inputs['RefsLength'] = [label_length]

    # edit distance op
    edit_distance_out = helper.create_variable_for_type_inference(dtype="int64")
    sequence_num = helper.create_variable_for_type_inference(dtype="int64")
581 582 583 584 585 586
    helper.append_op(
        type="edit_distance",
        inputs=this_inputs,
        outputs={"Out": [edit_distance_out], "SequenceNum": [sequence_num]},
        attrs={"normalized": normalized},
    )
587 588 589 590

    return edit_distance_out, sequence_num


591 592 593
def binary_cross_entropy(
    input, label, weight=None, reduction='mean', name=None
):
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651
    """
    This op measures 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 sigmod.  Available dtype is 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 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 candicates 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, 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 scalar.

    Examples:
        .. code-block:: python

            import paddle

652 653
            input = paddle.to_tensor([0.5, 0.6, 0.7], 'float32')
            label = paddle.to_tensor([1.0, 0.0, 1.0], 'float32')
654
            output = paddle.nn.functional.binary_cross_entropy(input, label)
N
Noel 已提交
655
            print(output)  # [0.65537095]
656 657 658 659 660

    """
    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "The value of 'reduction' in binary_cross_entropy should be 'sum', "
661 662 663
            "'mean' or 'none', but received %s, which is not allowed."
            % reduction
        )
664

J
Jiabin Yang 已提交
665
    if in_dygraph_mode():
666
        out = _C_ops.bce_loss(input, label)
667
        if weight is not None:
668
            out = _C_ops.multiply(out, weight, 'axis', -1)
669 670

        if reduction == 'sum':
671
            return _C_ops.sum(out, [], None, False)
672

673
        elif reduction == 'mean':
674
            return _C_ops.mean_all(out)
675 676 677
        else:
            return out
    else:
J
Jiabin Yang 已提交
678
        if _in_legacy_dygraph():
679
            out = _legacy_C_ops.bce_loss(input, label)
J
Jiabin Yang 已提交
680
            if weight is not None:
681
                out = _legacy_C_ops.elementwise_mul(out, weight, 'axis', -1)
J
Jiabin Yang 已提交
682
            if reduction == 'sum':
683 684 685
                return _legacy_C_ops.reduce_sum(
                    out, 'dim', [0], 'keep_dim', False, "reduce_all", True
                )
J
Jiabin Yang 已提交
686
            elif reduction == 'mean':
687
                return _legacy_C_ops.mean(out)
J
Jiabin Yang 已提交
688 689 690
            else:
                return out
        else:
691 692 693 694 695 696
            check_variable_and_dtype(
                input, 'input', ['float32', 'float64'], 'binary_cross_entropy'
            )
            check_variable_and_dtype(
                label, 'label', ['float32', 'float64'], 'binary_cross_entropy'
            )
J
Jiabin Yang 已提交
697 698 699 700

            sub_name = name if weight is None and reduction == 'none' else None
            helper = LayerHelper("binary_cross_entropy", name=sub_name)
            out = helper.create_variable_for_type_inference(dtype=input.dtype)
701 702 703 704 705 706 707 708
            helper.append_op(
                type='bce_loss',
                inputs={
                    'X': [input],
                    'Label': [label],
                },
                outputs={'Out': [out]},
            )
J
Jiabin Yang 已提交
709 710 711 712 713 714 715

            if weight is not None:
                if isinstance(weight, paddle.static.Variable):
                    weight_name = name if reduction == 'none' else None
                    out = paddle.multiply(out, weight, name=weight_name)
                else:
                    raise ValueError(
716 717
                        "The weight is not a Tensor, please convert to Tensor."
                    )
J
Jiabin Yang 已提交
718 719 720 721 722 723 724

            if reduction == 'sum':
                return paddle.sum(out, name=name)
            elif reduction == 'mean':
                return paddle.mean(out, name=name)
            else:
                return out
725 726


727 728 729
def binary_cross_entropy_with_logits(
    logit, label, weight=None, reduction='mean', pos_weight=None, name=None
):
730
    r"""
731 732 733 734 735 736 737 738 739 740 741
    This operator combines the sigmoid layer and the :ref:`api_nn_loss_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.

    First this operator calculate loss function as follows:

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

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

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

N
Noel 已提交
749
    For stability and to prevent overflow of :math:`e^{-Logit}` when Logit < 0,
750 751 752
    we reformulate the loss as follows:

    .. math::
753
           Out = \max(Logit, 0) - Logit * Labels + \log(1 + e^{-\|Logit\|})
754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797

    Then, if ``weight`` or ``pos_weight`` is not None, this operator 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, 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 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 candicates 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:
        output (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
N
Noel 已提交
798

799 800
            logit = paddle.to_tensor([5.0, 1.0, 3.0])
            label = paddle.to_tensor([1.0, 0.0, 1.0])
801
            output = paddle.nn.functional.binary_cross_entropy_with_logits(logit, label)
N
Noel 已提交
802
            print(output)  # [0.45618808]
803 804 805 806 807 808

    """
    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "The value of 'reduction' in binary_cross_entropy_with_logits "
            "should be 'sum', 'mean' or 'none', but received %s, which is not allowed."
809 810
            % reduction
        )
811

812
    if in_dygraph_mode():
813 814 815 816 817 818 819 820 821
        one = _C_ops.full(
            [1],
            float(1.0),
            core.VarDesc.VarType.FP32,
            _current_expected_place(),
        )
        out = _C_ops.sigmoid_cross_entropy_with_logits(
            logit, label, False, -100
        )
822
        if pos_weight is not None:
823
            log_weight = _C_ops.add(
824 825
                _C_ops.multiply(label, _C_ops.subtract(pos_weight, one)), one
            )
826
            out = _C_ops.multiply(out, log_weight)
827
        if weight is not None:
828
            out = _C_ops.multiply(out, weight)
829 830

        if reduction == "sum":
831
            return _C_ops.sum(out, [], None, False)
832
        elif reduction == "mean":
833
            return _C_ops.mean_all(out)
H
hong 已提交
834
        else:
835 836 837
            return out
    elif _in_legacy_dygraph():
        one = _varbase_creator(dtype=logit.dtype)
838 839 840 841 842 843 844 845 846 847 848 849 850
        _legacy_C_ops.fill_constant(
            one,
            'value',
            float(1.0),
            'force_cpu',
            False,
            'dtype',
            one.dtype,
            'str_value',
            '1.0',
            'shape',
            [1],
        )
851
        out = _legacy_C_ops.sigmoid_cross_entropy_with_logits(logit, label)
852
        if pos_weight is not None:
853 854
            log_weight = _legacy_C_ops.elementwise_add(
                _legacy_C_ops.elementwise_mul(
855 856 857 858
                    label, _legacy_C_ops.elementwise_sub(pos_weight, one)
                ),
                one,
            )
859
            out = _legacy_C_ops.elementwise_mul(out, log_weight)
860
        if weight is not None:
861
            out = _legacy_C_ops.elementwise_mul(out, weight)
862 863

        if reduction == "sum":
864
            return _legacy_C_ops.reduce_sum(out, 'reduce_all', True)
865
        elif reduction == "mean":
866
            return _legacy_C_ops.mean(out)
867 868 869
        else:
            return out

870 871 872 873 874 875 876 877 878 879 880 881
    check_variable_and_dtype(
        logit,
        'logit',
        ['float32', 'float64'],
        'binary_cross_entropy_with_logits',
    )
    check_variable_and_dtype(
        label,
        'label',
        ['float32', 'float64'],
        'binary_cross_entropy_with_logits',
    )
882 883 884 885
    sigmoid_name = None
    if reduction == 'none' and pos_weight is None and weight is None:
        sigmoid_name = name

886 887 888 889 890 891 892 893 894
    helper = LayerHelper("sigmoid_cross_entropy_with_logits", **locals())

    out = helper.create_variable_for_type_inference(dtype=logit.dtype)

    helper.append_op(
        type="sigmoid_cross_entropy_with_logits",
        inputs={"X": logit, "Label": label},
        attrs={"ignore_index": kIgnoreIndex, 'normalize': False},
        outputs={"Out": out},
895
    )
896

Z
zhiboniu 已提交
897
    one = paddle.full(shape=[1], fill_value=1.0, dtype=logit.dtype)
898
    if pos_weight is not None:
899 900 901 902 903 904
        check_variable_and_dtype(
            pos_weight,
            'pos_weight',
            ['float32', 'float64'],
            'binary_cross_entropy_with_logits',
        )
905
        log_weight = paddle.add(
906 907 908 909 910
            paddle.multiply(label, paddle.subtract(pos_weight, one)), one
        )
        pos_weight_name = (
            name if reduction == 'none' and weight is None else None
        )
911 912 913
        out = paddle.multiply(out, log_weight, name=pos_weight_name)

    if weight is not None:
914 915 916 917 918 919
        check_variable_and_dtype(
            weight,
            'weight',
            ['float32', 'float64'],
            'binary_cross_entropy_with_logits',
        )
920 921 922 923 924 925 926 927 928 929
        weight_name = name if reduction == 'none' else None
        out = paddle.multiply(out, weight, name=weight_name)

    if reduction == "sum":
        return paddle.sum(out, name=name)
    elif reduction == "mean":
        return paddle.mean(out, name=name)
    return out


930 931 932 933 934 935 936 937 938 939 940
def hsigmoid_loss(
    input,
    label,
    num_classes,
    weight,
    bias=None,
    path_table=None,
    path_code=None,
    is_sparse=False,
    name=None,
):
941 942 943
    """
    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.
944

945 946 947
    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.
948 949

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

952 953 954 955
    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):
956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001

    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, 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')

L
Linjie Chen 已提交
1002 1003 1004 1005 1006
            input = paddle.uniform([4, 3])
            # [[0.45424712  -0.77296764  0.82943869] # random
            #  [0.85062802  0.63303483  0.35312140] # random
            #  [0.57170701  0.16627562  0.21588242] # random
            #  [0.27610803  -0.99303514  -0.17114788]] # random
1007 1008 1009
            label = paddle.to_tensor([0, 1, 4, 5])
            num_classes = 5
            weight=paddle.uniform([num_classes-1, 3])
L
Linjie Chen 已提交
1010 1011 1012 1013
            # [[-0.64477652  0.24821866  -0.17456549] # random
            #  [-0.04635394  0.07473493  -0.25081766] # random
            #  [ 0.05986035  -0.12185556  0.45153677] # random
            #  [-0.66236806  0.91271877  -0.88088769]] # random
1014 1015

            out=F.hsigmoid_loss(input, label, num_classes, weight)
L
Linjie Chen 已提交
1016 1017 1018 1019
            # [[1.96709502]
            #  [2.40019274]
            #  [2.11009121]
            #  [1.92374969]]
1020
    """
1021
    if in_dygraph_mode():
1022
        out, _, _ = _C_ops.hsigmoid_loss(
1023 1024
            input,
            label,
1025 1026
            weight,
            bias,
1027 1028 1029 1030 1031 1032
            path_table,
            path_code,
            num_classes,
            is_sparse,
            is_sparse,
        )
1033 1034 1035
        return out
    elif _in_legacy_dygraph():
        out, _, _ = _legacy_C_ops.hierarchical_sigmoid(
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
            input,
            weight,
            label,
            path_table,
            path_code,
            bias,
            'num_classes',
            num_classes,
            'is_sparse',
            is_sparse,
            'remote_prefetch',
            is_sparse,
        )
1049 1050
        return out

1051 1052 1053
    check_variable_and_dtype(
        input, 'input', ['float32', 'float64'], 'hsigmoid_loss'
    )
1054
    check_variable_and_dtype(label, 'label', ['int64'], 'hsigmoid_loss')
1055 1056 1057
    check_variable_and_dtype(
        weight, 'weight', ['float32', 'float64'], 'hsigmoid_loss'
    )
1058
    if bias is not None:
1059 1060 1061
        check_variable_and_dtype(
            bias, 'bias', ['float32', 'float64'], 'hsigmoid_loss'
        )
1062
    if path_table is not None:
1063 1064 1065
        check_variable_and_dtype(
            path_table, 'path_table', ['int64'], 'hsigmoid_loss'
        )
1066
    if path_code is not None:
1067 1068 1069
        check_variable_and_dtype(
            path_code, 'path_code', ['int64'], 'hsigmoid_loss'
        )
1070 1071 1072 1073

    attrs = {
        "num_classes": num_classes,
        "is_sparse": is_sparse,
1074
        "remote_prefetch": is_sparse,
1075 1076 1077 1078 1079 1080 1081 1082
    }

    inputs = {
        "X": input,
        "W": weight,
        "Bias": bias,
        "PathTable": path_table,
        "PathCode": path_code,
1083
        "Label": label,
1084 1085 1086 1087 1088 1089 1090
    }

    helper = LayerHelper('hsigmoid_loss', **locals())
    out = helper.create_variable_for_type_inference(input.dtype)
    pre_out = helper.create_variable_for_type_inference(input.dtype)
    outputs = {"Out": out, "PreOut": pre_out, "W_Out": weight}

1091 1092 1093
    helper.append_op(
        type="hierarchical_sigmoid", inputs=inputs, outputs=outputs, attrs=attrs
    )
1094 1095 1096
    return out


1097
def smooth_l1_loss(input, label, reduction='mean', delta=1.0, name=None):
1098
    r"""
1099
    Calculate smooth_l1_loss. Creates a criterion that uses a squared
1100 1101 1102 1103 1104 1105
    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::

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


1109
    where :math:`z_i` is given by:
1110 1111 1112

    .. math::

1113
        \mathop{z_i} = \left\{\begin{array}{rcl}
1114 1115 1116
                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.
1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129

    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 candicates 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'``.
1130
        delta (float, optional): Specifies the hyperparameter :math:`\delta` to be used.
1131 1132 1133
            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
1134
        name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None.
1135 1136

    Returns:
1137
        Tensor, The tensor variable storing the smooth_l1_loss of input and label.
1138 1139 1140 1141 1142 1143

    Examples:
        .. code-block:: python

            import paddle

1144 1145
            input = paddle.rand([3, 3]).astype('float32')
            label = paddle.rand([3, 3]).astype('float32')
C
Chen Long 已提交
1146
            output = paddle.nn.functional.smooth_l1_loss(input, label)
G
Guanghua Yu 已提交
1147
            print(output)
1148
            # [0.068004]
1149
    """
1150 1151 1152 1153 1154 1155
    check_variable_and_dtype(
        input, 'input', ['float32', 'float64'], 'smooth_l1_loss'
    )
    check_variable_and_dtype(
        label, 'label', ['float32', 'float64'], 'smooth_l1_loss'
    )
1156

1157
    if in_dygraph_mode():
1158
        out, residual = _C_ops.huber_loss(input, label, delta)
1159 1160 1161
    else:
        helper = LayerHelper('huber_loss', **locals())
        residual = helper.create_variable_for_type_inference(
1162 1163
            dtype=helper.input_dtype()
        )
1164
        out = helper.create_variable_for_type_inference(
1165 1166 1167 1168 1169 1170 1171 1172
            dtype=helper.input_dtype()
        )
        helper.append_op(
            type='huber_loss',
            inputs={'X': input, 'Y': label},
            outputs={'Out': out, 'Residual': residual},
            attrs={'delta': delta},
        )
1173 1174 1175 1176

    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "The value of 'reduction' in smooth_l1_loss should be 'sum', 'mean' or"
1177 1178
            " 'none', but received %s, which is not allowed." % reduction
        )
1179 1180 1181
    if reduction == 'none':
        return out
    elif reduction == 'mean':
1182
        return paddle.mean(out)
1183
    elif reduction == 'sum':
1184
        return paddle.sum(out)
1185 1186


1187 1188 1189
def margin_ranking_loss(
    input, other, label, margin=0.0, reduction='mean', name=None
):
1190
    r"""
1191

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

1194
    .. math::
1195
        margin\_rank\_loss = max(0, -label * (input - other) + margin)
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211

    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.
1212
        label(Tensor): the label value corresponding to input, it's data type should be float32, float64.
1213 1214 1215 1216
        margin (float, optional): The margin value to add, default value is 0;
        reduction (str, optional): Indicate the reduction to apply to the loss, the candicates 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, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.

1217
    Returns:
1218
        Tensor, if :attr:`reduction` is ``'mean'`` or ``'sum'``, the out shape is :math:`[1]`, otherwise the shape is the same as `input` .The same dtype as input tensor.
1219 1220 1221 1222 1223

    Examples:

        .. code-block:: python

1224 1225
            import paddle

Z
Zhong Hui 已提交
1226 1227 1228
            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')
1229
            loss = paddle.nn.functional.margin_ranking_loss(input, other, label)
N
Noel 已提交
1230
            print(loss) # [0.75]
1231
    """
1232 1233 1234
    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "The value of 'reduction' in MarginRankingLoss should be 'sum', 'mean' or 'none', but "
1235 1236
            "received %s, which is not allowed." % reduction
        )
1237
    if in_dygraph_mode():
1238 1239
        out = _C_ops.subtract(other, input)
        out = _C_ops.multiply(out, label)
1240 1241
        if margin != 0.0:
            margin = fluid.dygraph.base.to_variable([margin], dtype=out.dtype)
1242 1243
            out = _C_ops.add(out, margin)
        out = _C_ops.relu(out)
1244
        if reduction == 'sum':
1245
            return _C_ops.sum(out, [], None, False)
1246
        elif reduction == 'mean':
1247
            return _C_ops.mean_all(out)
1248 1249
        return out
    elif _in_legacy_dygraph():
1250 1251
        out = _legacy_C_ops.elementwise_sub(other, input)
        out = _legacy_C_ops.elementwise_mul(out, label)
1252 1253
        if margin != 0.0:
            margin = fluid.dygraph.base.to_variable([margin], dtype=out.dtype)
1254 1255
            out = _legacy_C_ops.elementwise_add(out, margin)
        out = _legacy_C_ops.relu(out)
1256
        if reduction == 'sum':
1257
            return _legacy_C_ops.reduce_sum(out, 'reduce_all', True)
1258
        elif reduction == 'mean':
1259
            return _legacy_C_ops.mean(out)
1260 1261 1262
        return out

    helper = LayerHelper("margin_ranking_loss", **locals())
1263 1264 1265 1266 1267 1268 1269 1270 1271
    check_variable_and_dtype(
        input, 'input', ['float32', 'float64'], 'margin_rank_loss'
    )
    check_variable_and_dtype(
        other, 'other', ['float32', 'float64'], 'margin_rank_loss'
    )
    check_variable_and_dtype(
        label, 'label', ['float32', 'float64'], 'margin_rank_loss'
    )
1272

1273 1274 1275
    out = paddle.subtract(input, other)
    neg_label = paddle.neg(label)
    out = paddle.multiply(neg_label, out)
1276 1277 1278

    if margin != 0.0:
        margin_var = out.block.create_var(dtype=out.dtype)
Z
zhiboniu 已提交
1279
        margin_var = paddle.full(shape=[1], fill_value=margin, dtype=out.dtype)
1280 1281 1282 1283 1284
        out = paddle.add(out, margin_var)

    result_out = helper.create_variable_for_type_inference(input.dtype)

    if reduction == 'none':
1285 1286 1287
        helper.append_op(
            type="relu", inputs={"X": out}, outputs={"Out": result_out}
        )
1288 1289 1290 1291
        return result_out
    elif reduction == 'sum':
        out = paddle.nn.functional.relu(out)
        attrs = {"dim": [0], "keep_dim": False, "reduce_all": True}
1292 1293 1294 1295 1296 1297
        helper.append_op(
            type="reduce_sum",
            inputs={"X": out},
            outputs={"Out": result_out},
            attrs=attrs,
        )
1298 1299 1300
        return result_out
    elif reduction == 'mean':
        out = paddle.nn.functional.relu(out)
1301 1302 1303 1304 1305 1306
        helper.append_op(
            type="mean",
            inputs={"X": out},
            outputs={"Out": result_out},
            attrs={},
        )
1307 1308 1309
        return result_out


1310
def l1_loss(input, label, reduction='mean', name=None):
1311
    r"""
1312

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

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

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

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

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

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

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

1330

1331
    Parameters:
N
Noel 已提交
1332 1333
        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.
1334
        reduction (str, optional): Indicate the reduction to apply to the loss,
1335
            the candicates are ``'none'`` | ``'mean'`` | ``'sum'``.
1336 1337 1338
            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.
1339 1340
            Default is ``'mean'``.
        name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
N
Noel 已提交
1341

1342
    Returns:
1343
        Tensor, the L1 Loss of Tensor ``input`` and ``label``.
1344
        If `reduction` is ``'none'``, the shape of output loss is :math:`[N, *]`, the same as ``input`` .
1345
        If `reduction` is ``'mean'`` or ``'sum'``, the shape of output loss is [1].
N
Noel 已提交
1346

1347 1348
    Examples:
        .. code-block:: python
N
Noel 已提交
1349

1350
            import paddle
1351

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

1355
            l1_loss = paddle.nn.functional.l1_loss(input, label)
1356 1357 1358
            print(l1_loss)
            # Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True,
            #        [0.34999999])
1359

1360
            l1_loss = paddle.nn.functional.l1_loss(input, label, reduction='none')
1361 1362 1363 1364
            print(l1_loss)
            # Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=True,
            #        [[0.20000005, 0.19999999],
            #         [0.20000000, 0.79999995]])
1365

1366
            l1_loss = paddle.nn.functional.l1_loss(input, label, reduction='sum')
1367 1368 1369
            print(l1_loss)
            # Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True,
            #        [1.39999998])
1370

1371 1372 1373 1374
    """
    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "The value of 'reduction' in L1Loss should be 'sum', 'mean' or 'none', but "
1375 1376
            "received %s, which is not allowed." % reduction
        )
1377

1378
    if in_dygraph_mode():
1379 1380
        unreduced = _C_ops.abs(_C_ops.subtract(input, label))

1381
        if reduction == 'mean':
1382
            return _C_ops.mean_all(unreduced)
1383
        elif reduction == 'sum':
1384
            return _C_ops.sum(unreduced, [], None, False)
1385 1386
        else:
            return unreduced
1387
    elif _in_legacy_dygraph():
1388 1389 1390
        unreduced = _elementwise_op_in_dygraph(
            input, label, axis=-1, act='abs', op_name='elementwise_sub'
        )
1391
        if reduction == 'mean':
1392
            return _legacy_C_ops.mean(unreduced)
1393
        elif reduction == 'sum':
1394 1395 1396
            return _legacy_C_ops.reduce_sum(
                unreduced, 'dim', [0], 'keep_dim', False, 'reduce_all', True
            )
1397 1398 1399
        else:
            return unreduced

1400 1401 1402 1403 1404 1405
    check_variable_and_dtype(
        input, 'input', ['float32', 'float64', 'int32', 'int64'], 'l1_loss'
    )
    check_variable_and_dtype(
        label, 'label', ['float32', 'float64', 'int32', 'int64'], 'l1_loss'
    )
1406 1407

    if reduction == 'sum':
1408
        unreduced = paddle.abs(paddle.subtract(x=input, y=label))
1409 1410
        return paddle.sum(unreduced, name=name)
    elif reduction == 'mean':
1411
        unreduced = paddle.abs(paddle.subtract(x=input, y=label))
1412 1413
        return paddle.mean(unreduced, name=name)
    else:
1414
        return paddle.abs(paddle.subtract(x=input, y=label, name=name))
1415 1416 1417 1418 1419


def nll_loss(
    input, label, weight=None, ignore_index=-100, reduction='mean', name=None
):
1420 1421
    """
    This api returns negative log likelihood.
1422 1423
    See more detail in :ref:`NLLLoss <api_paddle_nn_NLLLoss>` .

1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434

    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'``.
1435 1436
         ignore_index (int, optional): Specifies a target value that is ignored
             and does not contribute to the input gradient. Default is -100.
1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
         reduction (str, optional): Indicate how to average the loss,
             the candicates 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 apllied.
             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 value of negative log likelihood loss.

    Examples:
        .. code-block:: python
1451

1452 1453 1454 1455
                import paddle
                from paddle.nn.functional import nll_loss
                log_softmax = paddle.nn.LogSoftmax(axis=1)

1456 1457 1458 1459 1460
                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")
1461
                log_out = log_softmax(input)
1462
                label = paddle.to_tensor([0, 2, 1, 1, 0], "int64")
1463
                result = nll_loss(log_out, label)
1464
                print(result) # Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=True, [1.07202101])
1465 1466 1467 1468
    """
    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "The value of 'reduction' in nll_loss should be 'sum', 'mean' or "
1469 1470
            "'none', but received %s, which is not allowed." % reduction
        )
1471 1472 1473 1474

    input_shape = list(input.shape)
    input_dims = len(input_shape)
    if input_dims < 2:
1475
        raise ValueError(
1476 1477
            'Expected 2 or more dimensions (got {})'.format(input_dims)
        )
1478 1479
    n = input_shape[0]
    c = input_shape[1]
Z
zyfncg 已提交
1480 1481
    if in_dygraph_mode():
        if input_dims != 2 and input_dims != 4:
1482 1483
            input = _C_ops.reshape(input, [n, c, 1, -1])
            label = _C_ops.reshape(label, [n, 1, -1])
Z
zyfncg 已提交
1484
            out_shape = [n] + input_shape[2:]
1485 1486 1487
        out, total_weight = _C_ops.nll_loss(
            input, label, weight, ignore_index, reduction
        )
Z
zyfncg 已提交
1488
        if input_dims != 2 and input_dims != 4 and reduction == 'none':
1489
            out = _C_ops.reshape(out, out_shape)
Z
zyfncg 已提交
1490
        return out
1491
    elif _in_legacy_dygraph():
1492
        if input_dims != 2 and input_dims != 4:
1493 1494 1495
            input, _ = _legacy_C_ops.reshape2(
                input, None, 'shape', [n, c, 1, -1]
            )
1496
            label, _ = _legacy_C_ops.reshape2(label, None, 'shape', [n, 1, -1])
1497
            out_shape = [n] + input_shape[2:]
H
hong 已提交
1498

1499 1500 1501 1502 1503 1504 1505 1506 1507
        out, total_weight = _legacy_C_ops.nll_loss(
            input,
            label,
            weight,
            'ignore_index',
            ignore_index,
            'reduction',
            reduction,
        )
1508
        if input_dims != 2 and input_dims != 4 and reduction == 'none':
1509
            out, _ = _legacy_C_ops.reshape2(out, None, 'shape', out_shape)
1510 1511 1512 1513 1514 1515 1516 1517 1518
        return out

    helper = LayerHelper('nll_loss', **locals())

    if input_dims != 2 and input_dims != 4:
        input = reshape(input, shape=[n, c, 1, -1])
        label = reshape(label, shape=[n, 1, -1])
        out_shape = [n] + input_shape[2:]

1519 1520
    check_variable_and_dtype(input, 'input', ['float32', 'float64'], 'nll_loss')
    check_variable_and_dtype(label, 'label', ['int64'], 'nll_loss')
1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
    inputs = {'X': input, 'Label': label}
    attrs = {'reduction': reduction, 'ignore_index': ignore_index}
    if weight is not None:
        if isinstance(weight, Variable):
            inputs['Weight'] = weight

    out = helper.create_variable_for_type_inference(dtype=input.dtype)
    total_weight = helper.create_variable_for_type_inference(dtype=input.dtype)
    outputs = {'Out': out, 'Total_weight': total_weight}

1531 1532 1533
    helper.append_op(
        type='nll_loss', inputs=inputs, outputs=outputs, attrs=attrs
    )
1534 1535 1536 1537
    if input_dims != 2 and input_dims != 4 and reduction == 'none':
        out = reshape(out, shape=out_shape)

    return out
1538 1539


1540
def kl_div(input, label, reduction='mean', name=None):
1541
    r"""
1542
    Calculate the Kullback-Leibler divergence loss
1543 1544 1545 1546 1547 1548 1549
    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:

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

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

1552
    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.
1553

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

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

1558
    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.
1559 1560

    Args:
1561
        input (Tensor): The input tensor. The shapes is [N, *], where N is batch size and `*` means
1562
            any number of additional dimensions. It's data type should be float32, float64.
1563
        label (Tensor): label. The shapes is [N, *], same shape as ``input`` . It's data type should be float32, float64.
1564 1565 1566 1567 1568 1569 1570
        reduction (str, optional): Indicate how to average the loss,
            the candicates 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 apllied.
            Default is ``'mean'``.
1571
        name(str, optional): Name for the operation (optional, default is None). For more information,
1572 1573 1574 1575 1576 1577 1578 1579 1580 1581
            please refer to :ref:`api_guide_Name`.

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

    Examples:
        .. code-block:: python

            import paddle
            import paddle.nn.functional as F
1582

1583
            shape = (5, 20)
1584 1585
            x = paddle.uniform(shape, min=-10, max=10).astype('float32')
            target = paddle.uniform(shape, min=-10, max=10).astype('float32')
1586

L
LielinJiang 已提交
1587
            # 'batchmean' reduction, loss shape will be [1]
1588
            pred_loss = F.kl_div(x, target, reduction='batchmean')
L
LielinJiang 已提交
1589
            # shape=[1]
1590

1591
            # 'mean' reduction, loss shape will be [1]
1592
            pred_loss = F.kl_div(x, target, reduction='mean')
1593 1594 1595
            # shape=[1]

            # 'sum' reduction, loss shape will be [1]
1596
            pred_loss = F.kl_div(x, target, reduction='sum')
1597 1598 1599
            # shape=[1]

            # 'none' reduction, loss shape is same with input shape
1600
            pred_loss = F.kl_div(x, target, reduction='none')
1601 1602 1603
            # shape=[5, 20]

    """
L
LielinJiang 已提交
1604
    # ugly type promotion
1605 1606 1607 1608
    if (
        fluid.data_feeder.convert_dtype(input.dtype) == 'float32'
        and fluid.data_feeder.convert_dtype(label.dtype) == 'float64'
    ):
1609
        input = paddle.cast(input, 'float64')
1610 1611 1612 1613
    elif (
        fluid.data_feeder.convert_dtype(input.dtype) == 'float64'
        and fluid.data_feeder.convert_dtype(label.dtype) == 'float32'
    ):
1614
        label = paddle.cast(label, 'float64')
L
LielinJiang 已提交
1615

1616
    if in_dygraph_mode():
1617
        out = _C_ops.kldiv_loss(input, label, 'none')
1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
        if reduction == 'mean':
            out = paddle.mean(out)
        elif reduction == 'sum':
            out = paddle.sum(out)
        elif reduction == 'batchmean':
            if len(input.shape) > 0:
                batch_size = input.shape[0]
                out = paddle.sum(out) / batch_size
        return out
    elif _in_legacy_dygraph():
1628
        out = _legacy_C_ops.kldiv_loss(input, label, 'reduction', 'none')
1629 1630 1631 1632 1633 1634 1635 1636
        if reduction == 'mean':
            out = paddle.mean(out)
        elif reduction == 'sum':
            out = paddle.sum(out)
        elif reduction == 'batchmean':
            if len(input.shape) > 0:
                batch_size = input.shape[0]
                out = paddle.sum(out) / batch_size
1637 1638 1639 1640
        return out

    helper = LayerHelper('kl_div', **locals())

1641 1642
    check_variable_and_dtype(input, 'input', ['float32', 'float64'], 'kl_div')
    check_variable_and_dtype(label, 'label', ['float32', 'float64'], 'kl_div')
1643 1644 1645
    fluid.data_feeder.check_type(reduction, 'reduction', str, 'kl_div')

    loss = helper.create_variable_for_type_inference(dtype=input.dtype)
1646 1647 1648 1649 1650 1651
    helper.append_op(
        type='kldiv_loss',
        inputs={'X': input, 'Target': label},
        outputs={'Loss': loss},
        attrs={'reduction': 'none'},
    )
1652 1653 1654 1655 1656 1657 1658 1659

    if reduction == 'mean':
        loss = paddle.mean(loss)
    elif reduction == 'sum':
        loss = paddle.sum(loss)
    elif reduction == 'batchmean':
        batch_size = paddle.shape(input)[0]
        loss = paddle.sum(loss) / batch_size
1660 1661 1662
    return loss


1663
def mse_loss(input, label, reduction='mean', name=None):
1664
    r"""
1665
    Accept input predications and label and returns the mean square error.
1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694

    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:
1695
        Tensor, The tensor tensor storing the mean square error difference of input and label.
1696

1697 1698 1699
    Examples:

        .. code-block:: python
1700

1701 1702
            import paddle
            mse_loss = paddle.nn.loss.MSELoss()
1703 1704
            input = paddle.to_tensor(1.5)
            label = paddle.to_tensor(1.7)
1705
            output = mse_loss(input, label)
B
Bai Yifan 已提交
1706
            print(output)
1707 1708 1709 1710 1711 1712 1713
            # [0.04000002]

    """

    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "'reduction' in 'mse_loss' should be 'sum', 'mean' or 'none', "
1714 1715
            "but received {}.".format(reduction)
        )
1716

Z
zhiboniu 已提交
1717
    if not in_dynamic_mode():
1718 1719 1720 1721 1722 1723
        check_variable_and_dtype(
            input, 'input', ['float32', 'float64'], 'mse_loss'
        )
        check_variable_and_dtype(
            label, 'label', ['float32', 'float64'], 'mse_loss'
        )
1724 1725

    if reduction == 'none':
1726
        return paddle.square(paddle.subtract(input, label), name=name)
1727
    elif reduction == 'mean':
1728 1729 1730
        return paddle.mean(
            paddle.square(paddle.subtract(input, label)), name=name
        )
1731
    else:
1732 1733 1734
        return paddle.sum(
            paddle.square(paddle.subtract(input, label)), name=name
        )
1735 1736


1737 1738 1739 1740 1741 1742 1743 1744 1745
def ctc_loss(
    log_probs,
    labels,
    input_lengths,
    label_lengths,
    blank=0,
    reduction='mean',
    norm_by_times=False,
):
1746 1747
    """

1748 1749 1750
    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
1751 1752 1753
    is interated to the Warp-CTC library to normalize values for each row of the input tensor.

    Parameters:
1754
        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.
1755 1756 1757 1758 1759
        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 is 0.
        reduction (string, optional): Indicate how to average the loss, the candicates 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 is ``'mean'``.
1760
        norm_by_times (bool, default False) – 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'.
H
Hui Zhang 已提交
1761

1762 1763
    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 [1]. Data type is the same as ``log_probs``.
1764

1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781
    Examples:

        .. code-block:: python

            # declarative mode
            import paddle.nn.functional as F
            import paddle

            # 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

1782
            log_probs = paddle.to_tensor([[[4.17021990e-01, 7.20324516e-01, 1.14374816e-04],
1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794
                                    [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],
1795 1796 1797 1798 1799 1800
                                    [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")
1801

1802 1803 1804 1805
            loss = F.ctc_loss(log_probs, labels,
                input_lengths,
                label_lengths,
                blank=0,
1806
                reduction='none')
1807 1808 1809
            print(loss)
            # Tensor(shape=[2], dtype=float32, place=Place(gpu:0), stop_gradient=True,
            #        [3.91798496, 2.90765190])
1810

1811 1812 1813 1814 1815
            loss = F.ctc_loss(log_probs, labels,
                input_lengths,
                label_lengths,
                blank=0,
                reduction='mean')
1816 1817 1818
            print(loss)
            # Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True,
            #        [1.13760614])
1819 1820 1821

    """

1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885
    def warpctc(
        input,
        label,
        blank=0,
        norm_by_times=False,
        input_length=None,
        label_length=None,
    ):
        if in_dygraph_mode():
            if input_length is None or label_length is None:
                raise ValueError(
                    "input_length and label_length must not be None in dygraph mode!"
                )
            loss_out = _C_ops.warpctc(
                input, label, input_length, label_length, blank, norm_by_times
            )
            return loss_out
        if _non_static_mode():
            if input_length is None or label_length is None:
                raise ValueError(
                    "input_length and label_length must not be None in dygraph mode!"
                )
            grad, loss_out = _legacy_C_ops.warpctc(
                input,
                label,
                input_length,
                label_length,
                'blank',
                blank,
                'norm_by_times',
                norm_by_times,
            )
            return loss_out
        helper = LayerHelper('warpctc', **locals())
        check_variable_and_dtype(
            input, 'input', ['float32', 'float64'], "warpctc"
        )
        check_variable_and_dtype(label, 'label', ['int32'], "warpctc")
        this_inputs = {'Logits': [input], 'Label': [label]}
        if input_length is not None and label_length is not None:
            check_variable_and_dtype(
                input_length, 'LogitsLength', ['int64'], "warpctc"
            )
            check_variable_and_dtype(
                label_length, 'LabelLength', ['int64'], "warpctc"
            )
            this_inputs['LogitsLength'] = [input_length]
            this_inputs['LabelLength'] = [label_length]

        loss_out = helper.create_variable_for_type_inference(dtype=input.dtype)
        grad_out = helper.create_variable_for_type_inference(dtype=input.dtype)

        helper.append_op(
            type='warpctc',
            inputs=this_inputs,
            outputs={'WarpCTCGrad': [grad_out], 'Loss': [loss_out]},
            attrs={
                'blank': blank,
                'norm_by_times': norm_by_times,
            },
        )
        return loss_out

    loss_out = warpctc(
1886 1887
        log_probs, labels, blank, norm_by_times, input_lengths, label_lengths
    )
1888

Z
zhiboniu 已提交
1889
    loss_out = paddle.squeeze(loss_out, [-1])
1890 1891
    assert reduction in ['mean', 'sum', 'none']
    if reduction == 'mean':
S
ShenLiang 已提交
1892
        loss_out = paddle.mean(loss_out / label_lengths)
1893 1894 1895 1896 1897
    elif reduction == 'sum':
        loss_out = paddle.sum(loss_out)
    return loss_out


1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908
def margin_cross_entropy(
    logits,
    label,
    margin1=1.0,
    margin2=0.5,
    margin3=0.0,
    scale=64.0,
    group=None,
    return_softmax=False,
    reduction='mean',
):
1909
    r"""
1910 1911
    .. math::

1912
        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}}}
1913

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

    .. hint::
1919 1920 1921 1922
        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.
1923 1924

    Args:
G
Guoxia Wang 已提交
1925
        logits (Tensor): shape[N, local_num_classes], the output of the normalized X multiply the normalized W.
1926
                The logits is shard_logits when using model parallel.
G
Guoxia Wang 已提交
1927 1928 1929 1930 1931
        label (Tensor): shape[N] or shape[N, 1], the groud 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`.
1932
        group (Group, optional): The group instance return by paddle.distributed.new_group
1933 1934
            or ``None`` for global default group or ``False`` for data parallel (do not communication cross ranks).
            Default is ``None``.
1935 1936 1937 1938 1939 1940 1941 1942
        return_softmax (bool, optional): Whether return softmax probability. Default value is `False`.
        reduction (str, optional): The candicates 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:
1943 1944 1945 1946 1947 1948
        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 ``[1]``.
1949 1950 1951 1952

    Examples:

    .. code-block:: python
G
Guoxia Wang 已提交
1953
        :name: code-example1
1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987

        # required: gpu
        # Single GPU
        import paddle
        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)
        print(label)
        print(loss)
        print(softmax)
1988

1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001
        #Tensor(shape=[2, 4], dtype=float64, place=CUDAPlace(0), stop_gradient=True,
        #       [[ 0.85204151, -0.55557678,  0.04994566,  0.71986042],
        #        [-0.20198586, -0.35270476, -0.55182702,  0.09749021]])
        #Tensor(shape=[2], dtype=int64, place=CUDAPlace(0), stop_gradient=True,
        #       [2, 3])
        #Tensor(shape=[2, 1], dtype=float64, place=CUDAPlace(0), stop_gradient=True,
        #       [[82.37059586],
        #        [12.13448420]])
        #Tensor(shape=[2, 4], dtype=float64, place=CUDAPlace(0), stop_gradient=True,
        #       [[0.99978819, 0.00000000, 0.00000000, 0.00021181],
        #        [0.99992995, 0.00006468, 0.00000000, 0.00000537]])

    .. code-block:: python
G
Guoxia Wang 已提交
2002
        :name: code-example2
2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048

        # required: distributed
        # Multi GPU, test_margin_cross_entropy.py
        import paddle
        import paddle.distributed as dist
        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')
        label_list = []
        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 = []
        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)

2049
        # python -m paddle.distributed.launch --gpus=0,1 test_margin_cross_entropy.py
2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092
        ## for rank0 input
        #Tensor(shape=[4, 4], dtype=float64, place=CUDAPlace(0), stop_gradient=True,
        #       [[ 0.32888934,  0.02408748, -0.02763289,  0.18173063],
        #        [-0.52893978, -0.10623845, -0.21596515, -0.06432517],
        #        [-0.00536345, -0.03924667,  0.66735314, -0.28640926],
        #        [-0.09907366, -0.48534973, -0.10365338, -0.39472322]])
        #Tensor(shape=[4], dtype=int64, place=CUDAPlace(0), stop_gradient=True,
        #       [11, 1 , 10, 11])

        ## for rank1 input
        #Tensor(shape=[4, 8], dtype=float64, place=CUDAPlace(1), stop_gradient=True,
        #       [[ 0.68654754,  0.28137170,  0.69694954, -0.60923933, -0.57077653,  0.54576703, -0.38709028,  0.56028204],
        #        [-0.80360371, -0.03042448, -0.45107338,  0.49559349,  0.69998950, -0.45411693,  0.61927630, -0.82808600],
        #        [ 0.11457570, -0.34785879, -0.68819499, -0.26189226, -0.48241491, -0.67685711,  0.06510185,  0.49660849],
        #        [ 0.31604851,  0.52087884,  0.53124749, -0.86176582, -0.43426329,  0.34786144, -0.10850784,  0.51566383]])
        #Tensor(shape=[4], dtype=int64, place=CUDAPlace(1), stop_gradient=True,
        #       [11, 1 , 10, 11])

        ## for rank0 output
        #Tensor(shape=[4, 1], dtype=float64, place=CUDAPlace(0), stop_gradient=True,
        #       [[38.96608230],
        #        [81.28152394],
        #        [69.67229865],
        #        [31.74197251]])
        #Tensor(shape=[4, 4], dtype=float64, place=CUDAPlace(0), stop_gradient=True,
        #       [[0.00000000, 0.00000000, 0.00000000, 0.00000000],
        #        [0.00000000, 0.00000000, 0.00000000, 0.00000000],
        #        [0.00000000, 0.00000000, 0.99998205, 0.00000000],
        #        [0.00000000, 0.00000000, 0.00000000, 0.00000000]])
        ## for rank1 output
        #Tensor(shape=[4, 1], dtype=float64, place=CUDAPlace(1), stop_gradient=True,
        #       [[38.96608230],
        #        [81.28152394],
        #        [69.67229865],
        #        [31.74197251]])
        #Tensor(shape=[4, 8], dtype=float64, place=CUDAPlace(1), stop_gradient=True,
        #       [[0.33943993, 0.00000000, 0.66051859, 0.00000000, 0.00000000, 0.00004148, 0.00000000, 0.00000000],
        #        [0.00000000, 0.00000000, 0.00000000, 0.00000207, 0.99432097, 0.00000000, 0.00567696, 0.00000000],
        #        [0.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00001795],
        #        [0.00000069, 0.33993085, 0.66006319, 0.00000000, 0.00000000, 0.00000528, 0.00000000, 0.00000000]])
    """

    assert reduction in ['mean', 'sum', 'none', None]
2093
    if not (group is False or group is None or hasattr(group, 'is_member')):
2094 2095
        raise ValueError(
            'Expected group is False, None or instance of paddle.distributed.collective.Group \
2096 2097 2098 2099
             (got group: {})'.format(
                group
            )
        )
2100 2101 2102
        return

    if hasattr(group, 'is_member') and not group.is_member():
2103 2104
        return

2105
    ring_id = 0
2106 2107
    rank = 0
    nranks = 1
2108
    if group is not False:
2109 2110 2111 2112
        ring_id = 0 if group is None else group.id
        if core.is_compiled_with_dist():
            parallel_env = paddle.distributed.ParallelEnv()
            global_rank = parallel_env.rank
2113 2114 2115 2116 2117
            rank = (
                global_rank
                if group is None
                else group.get_group_rank(global_rank)
            )
2118
            nranks = parallel_env.world_size if group is None else group.nranks
2119 2120 2121 2122 2123

    input_dims = len(list(logits.shape))
    label_dims = len(list(label.shape))
    if input_dims - 1 != label_dims and input_dims != label_dims:
        raise ValueError(
2124
            'Expected input_dims - 1 = label_dims or input_dims == label_dims\
2125 2126 2127 2128
             (got nput_dims{}, label_dims{})'.format(
                input_dims, label_dims
            )
        )
2129 2130 2131
    if input_dims - 1 == label_dims:
        label = paddle.unsqueeze(label, axis=-1)

2132
    if in_dygraph_mode():
2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144
        softmax, loss = _C_ops.margin_cross_entropy(
            logits,
            label,
            return_softmax,
            ring_id,
            rank,
            nranks,
            margin1,
            margin2,
            margin3,
            scale,
        )
2145 2146 2147 2148 2149 2150 2151 2152
        if reduction == 'mean':
            loss = paddle.mean(loss)
        elif reduction == 'sum':
            loss = paddle.sum(loss)
        if not return_softmax:
            return loss
        else:
            return loss, softmax
2153
    elif _in_legacy_dygraph():
2154
        softmax, loss = _legacy_C_ops.margin_cross_entropy(
2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173
            logits,
            label,
            'ring_id',
            ring_id,
            'rank',
            rank,
            'nranks',
            nranks,
            'margin1',
            margin1,
            'margin2',
            margin2,
            'margin3',
            margin3,
            'scale',
            scale,
            'return_softmax',
            return_softmax,
        )
2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187
        if reduction == 'mean':
            loss = paddle.mean(loss)
        elif reduction == 'sum':
            loss = paddle.sum(loss)
        if not return_softmax:
            return loss
        else:
            return loss, softmax

    op_type = 'margin_cross_entropy'
    helper = LayerHelper(op_type, **locals())
    softmax = helper.create_variable_for_type_inference(dtype=logits.dtype)
    loss = helper.create_variable_for_type_inference(dtype=logits.dtype)

2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212
    check_variable_and_dtype(
        logits,
        'logits',
        ['float16', 'float32', 'float64'],
        'margin_cross_entropy',
    )
    check_variable_and_dtype(
        label, 'label', ['int32', 'int64'], 'margin_cross_entropy'
    )

    helper.append_op(
        type=op_type,
        inputs={'Logits': logits, 'Label': label},
        outputs={'Softmax': softmax, 'Loss': loss},
        attrs={
            'return_softmax': return_softmax,
            'ring_id': ring_id,
            'rank': rank,
            'nranks': nranks,
            'margin1': margin1,
            'margin2': margin2,
            'margin3': margin3,
            'scale': scale,
        },
    )
2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224

    if reduction == 'mean':
        loss = paddle.mean(loss)
    elif reduction == 'sum':
        loss = paddle.sum(loss)

    if not return_softmax:
        return loss
    else:
        return loss, softmax


2225 2226 2227 2228
@deprecated(
    since="2.0.0",
    update_to="paddle.nn.functional.cross_entropy",
    level=1,
2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242
    reason=(
        'Please notice that behavior of "paddle.nn.functional.softmax_with_cross_entropy" '
        'and "paddle.nn.functional.cross_entropy" is different.'
    ),
)
def softmax_with_cross_entropy(
    logits,
    label,
    soft_label=False,
    ignore_index=-100,
    numeric_stable_mode=True,
    return_softmax=False,
    axis=-1,
):
2243
    r"""
2244 2245
    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
2246 2247 2248 2249 2250 2251
    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.

2252 2253 2254
    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
2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280
    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
2281 2282 2283
            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``
2284 2285 2286 2287 2288
            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 interpretant 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
2289
                                      if :attr:`soft_label` is set to :attr:`False`.
2290 2291 2292
                                      Default: kIgnoreIndex(-100).
        numeric_stable_mode (bool, optional): A flag to indicate whether to use a more
                                              numerically stable algorithm. Only valid
2293 2294 2295
                                              when :attr:`soft_label` is :attr:`False`
                                              and GPU is used. When :attr:`soft_label`
                                              is :attr:`True` or CPU is used, the
2296 2297 2298 2299 2300
                                              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.
2301
        axis (int, optional): The index of dimension to perform softmax calculations. It
2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316
                              should be in range :math:`[-1, rank - 1]`, while :math:`rank`
                              is the rank of input :attr:`logits`. Default: -1.

    Returns:
        ``Tensor`` or Tuple of two ``Tensor`` : Return the cross entropy loss if \
                                                    `return_softmax` is False, otherwise the tuple \
                                                    (loss, softmax), softmax is in the same shape \
                                                    with input logits and cross entropy loss is in \
                                                    the same shape with input logits except shape \
                                                    in dimension :attr:`axis` as 1.

    Examples:
        .. code-block:: python

            import paddle
2317 2318 2319 2320 2321

            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)
2322
            print(out)
2323 2324
            # Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True,
            #        [1.15328646])
2325
    """
2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347
    return fluid_softmax_with_cross_entropy(
        logits,
        label,
        soft_label,
        ignore_index,
        numeric_stable_mode,
        return_softmax,
        axis,
    )


def cross_entropy(
    input,
    label,
    weight=None,
    ignore_index=-100,
    reduction='mean',
    soft_label=False,
    axis=-1,
    use_softmax=True,
    name=None,
):
2348
    r"""
2349

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

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

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

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

2364
    The calculation includes the following two steps.
2365

2366
    - **1.softmax cross entropy**
2367

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

2370
        1.1. when use_softmax=True
2371

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

2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415
            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::
2416
                \\loss_j=loss_j*weight[label_j]
2417

2418

2419 2420 2421 2422 2423 2424 2425
            1.2. Soft labels (soft_label = True)

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

        2. reduction

2426
            2.1 if the ``reduction`` parameter is ``none``
2427 2428 2429

                Return the previous result directly

2430
            2.2 if the ``reduction`` parameter is ``sum``
2431 2432 2433 2434 2435 2436

                Return the sum of the previous results

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

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

2440
            2.3.1. If the  ``weight``  parameter is ``None``
2441 2442 2443

                   Return the average value of the previous results

2444
            .. math::
2445 2446 2447 2448 2449 2450 2451 2452
                \\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)

2453
            .. math::
2454
                \\loss=\sum_{j}loss_j/\sum_{j}weight[label_j]
2455 2456 2457

            2. Soft labels (soft_label = True)

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


2462
    Parameters:
2463
        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`` .
2464

2465
            Note:
2466
                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.
2467
                2. when use_softmax=False, it expects the output of softmax operator.
2468

2469
        label (Tensor):
2470 2471 2472 2473
            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].

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

2477
        weight (Tensor, optional): a manual rescaling weight given to each class.
2478
            If given, has to be a Tensor of size C and the data type is float32, float64.
2479
            Default is ``'None'`` .
2480
        ignore_index (int64, optional): Specifies a target value that is ignored
2481 2482
            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.
2483
            Default is ``-100`` .
2484
        reduction (str, optional): Indicate how to average the loss by batch_size,
2485 2486
            the candicates are ``'none'`` | ``'mean'`` | ``'sum'``.
            If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
H
Hui Zhang 已提交
2487
            If :attr:`size_average` is ``'sum'``, the reduced sum loss is returned.
2488 2489
            If :attr:`reduction` is ``'none'``, the unreduced loss is returned.
            Default is ``'mean'``.
2490 2491
        soft_label (bool, optional): Indicate whether label is soft. Default is ``False``.
        axis (int, optional):The index of dimension to perform softmax calculations.
2492 2493
            It should be in range :math:`[-1, rank - 1]`, where :math:`rank` is the
            number of dimensions of input :attr:`input`.
2494
            Default is ``-1`` .
2495
        use_softmax (bool, optional): Indicate whether compute softmax before cross_entropy.
2496
            Default is ``True``.
2497
        name (str, optional): The name of the operator. Default is ``None`` .
2498
            For more information, please refer to :ref:`api_guide_Name` .
2499 2500 2501

    Returns:

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

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

2507
        If :attr:`reduction` is ``'none'``:
C
Chen Long 已提交
2508

2509
        1. If soft_label = False, the dimension of return value is the same with ``label`` .
C
Chen Long 已提交
2510

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

2513
    Examples:
2514
        .. code-block:: python
2515 2516

            # hard labels
2517 2518 2519 2520 2521
            import paddle
            paddle.seed(99999)
            N=100
            C=200
            reduction='mean'
2522
            input =  paddle.rand([N, C], dtype='float64')
2523
            label =  paddle.randint(0, C, shape=[N], dtype='int64')
2524 2525
            weight = paddle.rand([C], dtype='float64')

2526 2527 2528
            cross_entropy_loss = paddle.nn.loss.CrossEntropyLoss(
                weight=weight, reduction=reduction)
            dy_ret = cross_entropy_loss(
2529 2530 2531 2532 2533
                                        input,
                                        label)
            print(dy_ret)
            # Tensor(shape=[1], dtype=float64, place=Place(gpu:0), stop_gradient=True,
            #        [5.34043430])
2534 2535

        .. code-block:: python
2536 2537

            # soft labels
2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550
            import paddle
            paddle.seed(99999)
            axis = -1
            ignore_index = -100
            N = 4
            C = 3
            shape = [N, C]
            reduction='mean'
            weight = 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(
2551 2552 2553 2554 2555 2556 2557 2558 2559
                                                                    logits,
                                                                    labels,
                                                                    soft_label=True,
                                                                    axis=axis,
                                                                    weight=weight,
                                                                    reduction=reduction)
            print(paddle_loss_mean)
            # Tensor(shape=[1], dtype=float64, place=Place(gpu:0), stop_gradient=True,
            #        [1.11043464])
C
Chen Long 已提交
2560

2561 2562 2563 2564
    """

    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
2565 2566
            "The value of 'reduction' in softmax_cross_entropy"
            "should be 'sum', 'mean' or 'none', but received %s, which is not allowed."
2567 2568
            % reduction
        )
2569
    if ignore_index > 0 and soft_label:
2570 2571
        raise ValueError(
            "When soft_label == True, the value of 'ignore_index' in softmax_cross_entropy"
2572 2573 2574
            "should be '-100', but received %s, which is not allowed."
            % ignore_index
        )
2575

2576
    input_dims = len(list(input.shape))
2577 2578 2579
    if input_dims == 0:
        raise ValueError('The dimention of input should be larger than zero!')

2580 2581
    label_dims = len(list(label.shape))
    if input_dims - 1 != label_dims and input_dims != label_dims:
2582
        raise ValueError(
2583
            'Expected nput_dims - 1 = label_dims or input_dims == label_dims\
2584 2585 2586 2587
             (got nput_dims{}, label_dims{})'.format(
                input_dims, label_dims
            )
        )
2588 2589
    if input_dims - 1 == label_dims:
        label = paddle.unsqueeze(label, axis=axis)
2590

2591
    if in_dygraph_mode():
2592
        if not soft_label:
2593 2594 2595
            valid_label = (
                paddle.cast(label != ignore_index, dtype=label.dtype) * label
            )
F
fwenguang 已提交
2596
        if core.is_compiled_with_npu() or core.is_compiled_with_mlu():
2597
            if not soft_label:
2598
                _, _, out = _legacy_C_ops.softmax_with_cross_entropy(
2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611
                    input,
                    valid_label,
                    'soft_label',
                    soft_label,
                    'ignore_index',
                    ignore_index,
                    'numeric_stable_mode',
                    True,
                    'axis',
                    axis,
                    'use_softmax',
                    use_softmax,
                )
2612
            else:
2613
                _, _, out = _legacy_C_ops.softmax_with_cross_entropy(
2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626
                    input,
                    label,
                    'soft_label',
                    soft_label,
                    'ignore_index',
                    ignore_index,
                    'numeric_stable_mode',
                    True,
                    'axis',
                    axis,
                    'use_softmax',
                    use_softmax,
                )
2627
        else:
2628 2629 2630
            _, out = _C_ops.cross_entropy_with_softmax(
                input, label, soft_label, use_softmax, True, ignore_index, axis
            )
2631 2632 2633 2634

        if weight is not None:

            # trans weight from class to sample, shape:N or [N,H,W] for 1d and 2d cases.
2635
            if soft_label:
2636 2637 2638 2639
                # chajchaj:
                # weight's shape is C, where C is class num.
                # for 1d case: label's shape is [N,C], weight_gather's shape is N.
                # for 2d case: label's shape is [N,H,W,C], weight_gather's shape is [N,H,W].
2640 2641 2642 2643 2644 2645
                weight_gather = paddle.matmul(
                    x=paddle.cast(label, weight.dtype),
                    y=weight,
                    transpose_x=False,
                    transpose_y=True,
                )
2646 2647 2648 2649
                out_shape = list(out.shape)
                weight_gather_reshape = reshape(weight_gather, shape=out_shape)
                out = paddle.cast(out, weight_gather_reshape.dtype)

2650
                out = _C_ops.multiply(out, weight_gather_reshape)
2651 2652 2653 2654 2655
            else:
                if input.shape[axis] != weight.shape[-1]:
                    raise ValueError(
                        "input's class_dimension({}) must equal to "
                        "weight's class_dimension({}) "
2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667
                        "when weight is provided".format(
                            input.shape[axis], weight.shape[-1]
                        )
                    )

                ignore_weight_mask = paddle.cast(
                    (label != ignore_index), out.dtype
                )
                if (
                    ignore_weight_mask.ndim > 1
                    and ignore_weight_mask.shape[axis] == 1
                ):
2668
                    # TODO: Temporarily use squeeze instead of squeeze_
2669 2670 2671
                    ignore_weight_mask = paddle.squeeze(
                        ignore_weight_mask, axis
                    )
2672
                if axis != -1 and axis != valid_label.ndim - 1:
2673 2674 2675 2676 2677 2678 2679 2680 2681
                    temp_perm = (
                        list(range(axis % valid_label.ndim))
                        + list(
                            range(
                                (axis % valid_label.ndim + 1), valid_label.ndim
                            )
                        )
                        + [axis % valid_label.ndim]
                    )
2682
                    weight_gather = _C_ops.gather_nd(
2683 2684
                        weight, valid_label.transpose(temp_perm)
                    )
2685
                else:
2686
                    weight_gather = _C_ops.gather_nd(weight, valid_label)
2687 2688 2689
                weight_gather = _C_ops.multiply(
                    weight_gather, ignore_weight_mask
                )
2690
                input_shape = list(label.shape)
2691 2692 2693
                weight_gather_reshape = reshape(
                    weight_gather, shape=input_shape
                )
2694
                out = paddle.cast(out, weight_gather_reshape.dtype)
2695
                out = _C_ops.multiply(out, weight_gather_reshape)
2696 2697 2698 2699 2700

        if reduction == "sum":
            #   because of fluid_softmax_with_cross_entropy op's inner logic,
            #   in the out tensor of this op, the loss of sample with class_index==ignore_index is 0
            #   so, reduce_sum all directly is ok
2701
            return _C_ops.sum(out, [], None, False)
2702 2703 2704 2705 2706 2707 2708 2709
        elif reduction == "mean":
            # 1. if weight==none,
            #     numerator: reduce_sum all loss directly is ok causeof fluid_softmax_with_cross_entropy's inner logic
            #     denominator: count sample num with class_index!=ignore_index
            # 2. else
            #     numerator: loss's weighted sum
            #     denominator: cal the sum of weight where the sample's class_index!=ignore_index
            if ignore_index >= 0:
2710
                out_sum = _C_ops.sum(out, [], None, False)
2711 2712 2713
                # for each label[i],set 1 or 0, according to ignore_index
                # mask[i]=0, if label[i]==ignore_index
                # mask[i]=1, otherwise
2714
                mask = label != ignore_index
2715 2716
                if weight is None:
                    mask = paddle.cast(mask, dtype=out_sum.dtype)
2717
                    count = _C_ops.sum(mask, [], None, False)
2718 2719 2720
                    ret = out_sum / (count + (count == 0.0))
                else:
                    mask = paddle.cast(mask, weight_gather_reshape.dtype)
2721 2722 2723
                    weight_ignored = _C_ops.multiply(
                        mask, weight_gather_reshape
                    )
2724
                    weight_sum = _C_ops.sum(weight_ignored, [], None, False)
2725 2726 2727
                    ret = out_sum / (weight_sum + (weight_sum == 0.0))
                return ret
            elif weight is not None:
2728
                out_sum = _C_ops.sum(out, [], None, False)
2729 2730 2731
                total_weight = _C_ops.sum(
                    weight_gather_reshape, [], None, False
                )
2732 2733
                return out_sum / (total_weight + (total_weight == 0.0))
            else:
2734
                return _C_ops.mean_all(out)
2735 2736 2737 2738 2739 2740 2741

        else:
            if input_dims - 1 == label_dims:
                out = paddle.squeeze(out, axis=axis)
            return out

    elif _in_legacy_dygraph():
2742
        if not soft_label:
2743 2744 2745
            valid_label = (
                paddle.cast(label != ignore_index, dtype=label.dtype) * label
            )
2746 2747 2748
            label_min = paddle.min(valid_label)
            label_max = paddle.max(valid_label)
            if label_min < 0:
2749 2750 2751
                raise ValueError(
                    "Target {} is out of lower bound.".format(label_min.item())
                )
2752
            if label_max >= input.shape[axis]:
2753 2754 2755
                raise ValueError(
                    "Target {} is out of upper bound.".format(label_max.item())
                )
2756
        if core.is_compiled_with_npu() or core.is_compiled_with_mlu():
2757
            if not soft_label:
2758
                _, _, out = _legacy_C_ops.softmax_with_cross_entropy(
2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771
                    input,
                    valid_label,
                    'soft_label',
                    soft_label,
                    'ignore_index',
                    ignore_index,
                    'numeric_stable_mode',
                    True,
                    'axis',
                    axis,
                    'use_softmax',
                    use_softmax,
                )
2772
            else:
2773
                _, _, out = _legacy_C_ops.softmax_with_cross_entropy(
2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786
                    input,
                    label,
                    'soft_label',
                    soft_label,
                    'ignore_index',
                    ignore_index,
                    'numeric_stable_mode',
                    True,
                    'axis',
                    axis,
                    'use_softmax',
                    use_softmax,
                )
2787
        else:
2788
            _, out = _legacy_C_ops.softmax_with_cross_entropy(
2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801
                input,
                label,
                'soft_label',
                soft_label,
                'ignore_index',
                ignore_index,
                'numeric_stable_mode',
                True,
                'axis',
                axis,
                'use_softmax',
                use_softmax,
            )
2802

2803
        if weight is not None:
2804

H
HydrogenSulfate 已提交
2805
            # trans weight from class to sample, shape:N or [N,H,W] for 1d and 2d cases.
2806
            if soft_label:
2807
                # chajchaj:
H
HydrogenSulfate 已提交
2808
                # weight's shape is C, where C is class num.
2809 2810
                # for 1d case: label's shape is [N,C], weight_gather's shape is N.
                # for 2d case: label's shape is [N,H,W,C], weight_gather's shape is [N,H,W].
2811 2812 2813 2814 2815 2816
                weight_gather = paddle.matmul(
                    x=paddle.cast(label, weight.dtype),
                    y=weight,
                    transpose_x=False,
                    transpose_y=True,
                )
2817 2818 2819 2820
                out_shape = list(out.shape)
                weight_gather_reshape = reshape(weight_gather, shape=out_shape)
                out = paddle.cast(out, weight_gather_reshape.dtype)

2821
                out = _legacy_C_ops.elementwise_mul(out, weight_gather_reshape)
2822 2823

            else:
2824 2825 2826 2827
                if input.shape[axis] != weight.shape[-1]:
                    raise ValueError(
                        "input's class_dimension({}) must equal to "
                        "weight's class_dimension({}) "
2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839
                        "when weight is provided".format(
                            input.shape[axis], weight.shape[-1]
                        )
                    )

                ignore_weight_mask = paddle.cast(
                    (label != ignore_index), out.dtype
                )
                if (
                    ignore_weight_mask.ndim > 1
                    and ignore_weight_mask.shape[axis] == 1
                ):
H
HydrogenSulfate 已提交
2840
                    # TODO: Temporarily use squeeze instead of squeeze_
2841 2842 2843
                    ignore_weight_mask = paddle.squeeze(
                        ignore_weight_mask, axis
                    )
H
HydrogenSulfate 已提交
2844
                if axis != -1 and axis != valid_label.ndim - 1:
2845 2846 2847 2848 2849 2850 2851 2852 2853
                    temp_perm = (
                        list(range(axis % valid_label.ndim))
                        + list(
                            range(
                                (axis % valid_label.ndim + 1), valid_label.ndim
                            )
                        )
                        + [axis % valid_label.ndim]
                    )
2854
                    weight_gather = _legacy_C_ops.gather_nd(
2855 2856
                        weight, valid_label.transpose(temp_perm)
                    )
2857
                else:
2858 2859
                    weight_gather = _legacy_C_ops.gather_nd(weight, valid_label)
                weight_gather = _legacy_C_ops.elementwise_mul(
2860 2861
                    weight_gather, ignore_weight_mask
                )
2862
                input_shape = list(label.shape)
2863 2864 2865
                weight_gather_reshape = reshape(
                    weight_gather, shape=input_shape
                )
2866
                out = paddle.cast(out, weight_gather_reshape.dtype)
2867
                out = _legacy_C_ops.elementwise_mul(out, weight_gather_reshape)
2868

2869
        if reduction == "sum":
H
HydrogenSulfate 已提交
2870
            #   because of fluid_softmax_with_cross_entropy op's inner logic,
2871 2872
            #   in the out tensor of this op, the loss of sample with class_index==ignore_index is 0
            #   so, reduce_sum all directly is ok
2873
            return _legacy_C_ops.reduce_sum(out, 'reduce_all', True)
2874
        elif reduction == "mean":
H
HydrogenSulfate 已提交
2875 2876 2877 2878 2879 2880
            # 1. if weight==none,
            #     numerator: reduce_sum all loss directly is ok causeof fluid_softmax_with_cross_entropy's inner logic
            #     denominator: count sample num with class_index!=ignore_index
            # 2. else
            #     numerator: loss's weighted sum
            #     denominator: cal the sum of weight where the sample's class_index!=ignore_index
S
sneaxiy 已提交
2881
            if ignore_index >= 0:
2882
                out_sum = _legacy_C_ops.reduce_sum(out, 'reduce_all', True)
H
HydrogenSulfate 已提交
2883 2884 2885
                # for each label[i],set 1 or 0, according to ignore_index
                # mask[i]=0, if label[i]==ignore_index
                # mask[i]=1, otherwise
2886
                mask = label != ignore_index
2887
                if weight is None:
2888
                    mask = paddle.cast(mask, dtype=out_sum.dtype)
2889
                    count = _legacy_C_ops.reduce_sum(mask, 'reduce_all', True)
2890
                    ret = out_sum / (count + (count == 0.0))
2891 2892
                else:
                    mask = paddle.cast(mask, weight_gather_reshape.dtype)
2893
                    weight_ignored = _legacy_C_ops.elementwise_mul(
2894 2895
                        mask, weight_gather_reshape
                    )
2896
                    weight_sum = _legacy_C_ops.reduce_sum(
2897 2898
                        weight_ignored, 'reduce_all', True
                    )
2899
                    ret = out_sum / (weight_sum + (weight_sum == 0.0))
2900 2901
                return ret
            elif weight is not None:
2902
                out_sum = _legacy_C_ops.reduce_sum(out, 'reduce_all', True)
2903 2904 2905
                total_weight = _legacy_C_ops.reduce_sum(
                    weight_gather_reshape, 'reduce_all', True
                )
2906
                return out_sum / (total_weight + (total_weight == 0.0))
2907
            else:
2908
                return _legacy_C_ops.mean(out)
2909
        else:
2910 2911
            if input_dims - 1 == label_dims:
                out = paddle.squeeze(out, axis=axis)
2912
            return out
2913

2914
    check_variable_and_dtype(
2915 2916 2917 2918 2919 2920 2921 2922
        input,
        'input',
        ['float16', 'float32', 'float64'],
        'softmax_cross_entropy',
    )
    check_variable_and_dtype(
        label,
        'label',
2923
        ['uint8', 'int8', 'int16', 'int32', 'int64', 'float32', 'float64'],
2924 2925
        'softmax_cross_entropy',
    )
2926 2927 2928 2929 2930
    attrs = {
        'soft_label': soft_label,
        'ignore_index': ignore_index,
        'numeric_stable_mode': True,
        'axis': axis,
2931
        'use_softmax': use_softmax,
2932 2933 2934 2935
    }
    helper = LayerHelper('softmax_with_cross_entropy', **locals())
    softmax = helper.create_variable_for_type_inference(dtype=input.dtype)
    out = helper.create_variable_for_type_inference(dtype=input.dtype)
2936 2937 2938 2939 2940

    outputs = {'Softmax': softmax, 'Loss': out}
    if core.is_compiled_with_npu() or core.is_compiled_with_mlu():
        backprop = helper.create_variable_for_type_inference(dtype=input.dtype)
        outputs['Backprop'] = backprop
2941 2942 2943 2944 2945 2946
    helper.append_op(
        type='softmax_with_cross_entropy',
        inputs={'Logits': input, 'Label': label},
        outputs=outputs,
        attrs=attrs,
    )
2947

2948
    if weight is not None:
2949 2950 2951
        check_variable_and_dtype(
            weight, 'weight', ['float32', 'float64'], 'softmax_cross_entropy'
        )
2952
        weight_name = name if reduction == 'none' else None
2953
        if soft_label:
2954
            # chajchaj:
H
HydrogenSulfate 已提交
2955
            # trans weight from class to sample, shape:N or [N,H,W] for 1d and 2d cases.
2956 2957 2958
            # weight's shape is C, where C is class num.
            # for 1d case: label's shape is [N,C], weight_gather's shape is N.
            # for 2d case: label's shape is [N,H,W,C], weight_gather's shape is [N,H,W].
2959 2960 2961 2962 2963 2964
            weight_gather = paddle.matmul(
                x=paddle.cast(label, weight.dtype),
                y=weight,
                transpose_x=False,
                transpose_y=True,
            )
2965 2966 2967 2968 2969

            out_shape = list(out.shape)
            weight_gather_reshape = reshape(weight_gather, shape=out_shape)
            out = paddle.cast(out, weight_gather_reshape.dtype)
        else:
2970
            if input.shape[axis] != weight.shape[-1]:
2971 2972 2973 2974 2975 2976 2977
                raise ValueError(
                    "input's class_dimension({}) must equal to "
                    "weight's class_dimension({}) "
                    "when weight is provided".format(
                        input.shape[axis], weight.shape[-1]
                    )
                )
H
HydrogenSulfate 已提交
2978

H
HydrogenSulfate 已提交
2979
            valid_label = paddle.multiply(
2980 2981 2982 2983 2984 2985 2986 2987 2988
                paddle.cast(label != ignore_index, dtype=label.dtype), label
            )
            ignore_weight_mask = paddle.cast(
                (label != ignore_index), input.dtype
            )
            if (
                ignore_weight_mask.ndim > 1
                and ignore_weight_mask.shape[axis] == 1
            ):
2989
                ignore_weight_mask = paddle.squeeze(ignore_weight_mask, axis)
H
HydrogenSulfate 已提交
2990
            if axis != -1 and axis != valid_label.ndim - 1:
2991 2992 2993 2994 2995 2996 2997
                temp_perm = (
                    list(range(axis % valid_label.ndim))
                    + list(
                        range((axis % valid_label.ndim + 1), valid_label.ndim)
                    )
                    + [axis % valid_label.ndim]
                )
2998
                weight_gather = paddle.gather_nd(
2999 3000
                    weight, paddle.transpose(valid_label, temp_perm)
                )
3001 3002
            else:
                weight_gather = paddle.gather_nd(weight, valid_label)
H
HydrogenSulfate 已提交
3003 3004
            weight_gather = paddle.multiply(weight_gather, ignore_weight_mask)

3005 3006
            input_shape = list(label.shape)
            weight_gather_reshape = reshape(weight_gather, shape=input_shape)
3007
        out = paddle.multiply(out, weight_gather_reshape, name=weight_name)
3008

3009 3010 3011
    if reduction == "sum":
        return paddle.sum(out, name=name)
    elif reduction == "mean":
S
sneaxiy 已提交
3012
        if ignore_index >= 0:
3013
            out_sum = paddle.sum(out, name=name)
H
HydrogenSulfate 已提交
3014 3015 3016
            # for each label[i],set 1 or 0, according to ignore_index
            # mask[i]=0, if label[i]==ignore_index
            # mask[i]=1, otherwise
3017 3018
            mask = label != ignore_index
            if weight is None:
3019 3020
                mask = paddle.cast(mask, dtype=out_sum.dtype)
                count = paddle.sum(mask, name=name)
3021
                ret = out_sum / (count + (count == 0.0))
3022 3023 3024 3025
            else:
                mask = paddle.cast(mask, weight_gather_reshape.dtype)
                weight_ignored = paddle.multiply(mask, weight_gather_reshape)
                weight_sum = paddle.sum(weight_ignored, name=name)
3026
                ret = out_sum / (weight_sum + (weight_sum == 0.0))
3027 3028
            return ret
        elif weight is not None:
3029 3030
            out_sum = paddle.sum(out, name=name)
            total_weight = paddle.sum(weight_gather_reshape)
3031
            return out_sum / (total_weight + (total_weight == 0.0))
3032 3033
        else:
            return paddle.mean(out, name=name)
3034

3035
    else:
3036 3037 3038
        if input_dims - 1 == label_dims:
            out = paddle.squeeze(out, axis=axis)

3039
        return out
3040 3041


3042 3043 3044 3045 3046 3047 3048 3049 3050
def sigmoid_focal_loss(
    logit,
    label,
    normalizer=None,
    alpha=0.25,
    gamma=2.0,
    reduction='sum',
    name=None,
):
3051
    r"""
3052 3053 3054 3055 3056 3057
    `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.

3058
    This operator measures focal loss function as follows:
3059 3060

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

3063
    We know that :math:`\sigma(Logit) = \frac{1}{1 + \exp(-Logit)}`.
3064 3065 3066 3067 3068

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

    .. math::
3069
           Out = \frac{Out}{normalizer}
3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086

    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 whose shape is `[1, ]`. The data type is float32, float64.
3087
            For object detection task, it is the number of positive samples.
3088 3089
            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,
3090
            it should be between 0 and 1.  Default value is set to 0.25.
3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114
        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 candicates 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, 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:`[1]`, 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)
3115
            fg_num = paddle.sum(paddle.cast(fg_label, dtype='float32'))
3116
            output = paddle.nn.functional.sigmoid_focal_loss(logit, label, normalizer=fg_num)
3117
            print(output)  # [0.65782464]
3118 3119 3120 3121 3122 3123

    """
    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "The value of 'reduction' in sigmoid_focal_loss "
            "should be 'sum', 'mean' or 'none', but received %s, which is not allowed."
3124 3125
            % reduction
        )
3126 3127

    if normalizer is not None:
3128 3129 3130 3131 3132 3133
        check_variable_and_dtype(
            normalizer,
            'normalizer',
            ['float32', 'float64'],
            'sigmoid_focal_loss',
        )
3134 3135 3136 3137
        normalizer_shape = list(normalizer.shape)
        normalizer_dims = len(normalizer_shape)
        if normalizer_dims > 1:
            raise ValueError(
3138 3139 3140 3141
                "Expected one dimension of normalizer in sigmoid_focal_loss but got {}.".format(
                    normalizer_dims
                )
            )
3142

3143 3144
    if in_dygraph_mode():
        place = _current_expected_place()
3145
        one = _C_ops.full(logit.shape, float(1.0), logit.dtype, place)
3146

3147 3148 3149
        loss = _C_ops.sigmoid_cross_entropy_with_logits(
            logit, label, False, -100
        )
3150

3151
        pred = _C_ops.sigmoid(logit)
3152

3153 3154
        p_t = _C_ops.add(
            _C_ops.multiply(pred, label),
3155 3156 3157 3158
            _C_ops.multiply(
                _C_ops.subtract(one, pred), _C_ops.subtract(one, label)
            ),
        )
3159 3160

        alpha = fluid.dygraph.base.to_variable([alpha], dtype=loss.dtype)
3161 3162
        alpha_t = _C_ops.add(
            _C_ops.multiply(alpha, label),
3163 3164 3165 3166
            _C_ops.multiply(
                _C_ops.subtract(one, alpha), _C_ops.subtract(one, label)
            ),
        )
3167
        loss = _C_ops.multiply(alpha_t, loss)
3168 3169

        gamma = fluid.dygraph.base.to_variable([gamma], dtype=loss.dtype)
3170 3171
        gamma_t = _C_ops.pow(_C_ops.subtract(one, p_t), gamma)
        loss = _C_ops.multiply(gamma_t, loss)
3172 3173

        if normalizer is not None:
3174
            loss = _C_ops.divide(loss, normalizer)
3175 3176

        if reduction == "sum":
3177
            return _C_ops.sum(loss, [], None, False)
3178
        elif reduction == "mean":
3179
            return _C_ops.mean_all(loss)
3180 3181 3182 3183 3184

        return loss

    elif _in_legacy_dygraph():
        one = _varbase_creator(dtype=logit.dtype)
3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197
        _legacy_C_ops.fill_constant(
            one,
            'value',
            float(1.0),
            'force_cpu',
            False,
            'dtype',
            one.dtype,
            'str_value',
            '1.0',
            'shape',
            logit.shape,
        )
3198
        loss = _legacy_C_ops.sigmoid_cross_entropy_with_logits(logit, label)
3199

3200
        pred = _legacy_C_ops.sigmoid(logit)
3201

3202 3203 3204 3205
        p_t = _legacy_C_ops.elementwise_add(
            _legacy_C_ops.elementwise_mul(pred, label),
            _legacy_C_ops.elementwise_mul(
                _legacy_C_ops.elementwise_sub(one, pred),
3206 3207 3208
                _legacy_C_ops.elementwise_sub(one, label),
            ),
        )
3209 3210

        alpha = fluid.dygraph.base.to_variable([alpha], dtype=loss.dtype)
3211 3212 3213 3214
        alpha_t = _legacy_C_ops.elementwise_add(
            _legacy_C_ops.elementwise_mul(alpha, label),
            _legacy_C_ops.elementwise_mul(
                _legacy_C_ops.elementwise_sub(one, alpha),
3215 3216 3217
                _legacy_C_ops.elementwise_sub(one, label),
            ),
        )
3218
        loss = _legacy_C_ops.elementwise_mul(alpha_t, loss)
3219 3220

        gamma = fluid.dygraph.base.to_variable([gamma], dtype=loss.dtype)
3221
        gamma_t = _legacy_C_ops.elementwise_pow(
3222 3223
            _legacy_C_ops.elementwise_sub(one, p_t), gamma
        )
3224
        loss = _legacy_C_ops.elementwise_mul(gamma_t, loss)
3225 3226

        if normalizer is not None:
3227
            loss = _legacy_C_ops.elementwise_div(loss, normalizer)
3228 3229

        if reduction == "sum":
3230
            return _legacy_C_ops.reduce_sum(loss, 'reduce_all', True)
3231
        elif reduction == "mean":
3232
            return _legacy_C_ops.mean(loss)
3233 3234 3235

        return loss

3236 3237 3238 3239 3240 3241
    check_variable_and_dtype(
        logit, 'logit', ['float32', 'float64'], 'sigmoid_focal_loss'
    )
    check_variable_and_dtype(
        label, 'label', ['float32', 'float64'], 'sigmoid_focal_loss'
    )
3242 3243 3244 3245 3246

    bce_name = None
    if reduction == 'none' and normalizer is None:
        bce_name = name
    loss = paddle.nn.functional.binary_cross_entropy_with_logits(
3247 3248
        logit, label, reduction='none', name=bce_name
    )
3249

Z
zhiboniu 已提交
3250
    pred = paddle.nn.functional.sigmoid(logit)
3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268
    p_t = pred * label + (1 - pred) * (1 - label)

    alpha_t = alpha * label + (1 - alpha) * (1 - label)
    loss = paddle.multiply(alpha_t, loss)

    gamma_t = paddle.pow((1 - p_t), gamma)
    loss = paddle.multiply(gamma_t, loss)

    if normalizer is not None:
        normalizer_name = name if reduction == 'none' else None
        loss = paddle.divide(loss, normalizer, name=normalizer_name)

    if reduction == 'mean':
        loss = paddle.mean(loss, name=name)
    elif reduction == 'sum':
        loss = paddle.sum(loss, name=name)

    return loss
3269 3270


3271 3272 3273
def multi_label_soft_margin_loss(
    input, label, weight=None, reduction="mean", name=None
):
Y
yangguohao 已提交
3274
    r"""
3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287
    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) = \sum_{ij}\frac{\max(0, 1 - (x[y[j]] - x[i]))}{\text{x.size}(0)}

    where :math:`x \in \left\{0, \; \cdots , \; \text{x.size}(0) - 1\right\}`, \
    :math:`y \in \left\{0, \; \cdots , \; \text{y.size}(0) - 1\right\}`, \
    :math:`0 \leq y[j] \leq \text{x.size}(0)-1`, \
    and :math:`i \neq y[j]` for all :math:`i` and :math:`j`.
    :math:`y` and :math:`x` must have the same size.
Y
yangguohao 已提交
3288

3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302
    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 candicates 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, optional): Name for the operation (optional, default is None).
                For more information, please refer to :ref:`api_guide_Name`.
Y
yangguohao 已提交
3303

3304 3305 3306 3307 3308
    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 operationoperates 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.
Y
yangguohao 已提交
3309

3310 3311
    Returns:
        Tensor, The tensor variable storing the multi_label_soft_margin_loss of input and label.
Y
yangguohao 已提交
3312

3313 3314
    Examples:
        .. code-block:: python
Y
yangguohao 已提交
3315

3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326
            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([3.49625897, 0.71111226, 0.43989015])
            loss = F.multi_label_soft_margin_loss(input, label, reduction='mean')
            print(loss)
            # Tensor([1.54908717])
Y
yangguohao 已提交
3327 3328 3329 3330
    """
    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "'reduction' in 'multi_label_soft_margin_loss' should be 'sum', 'mean' or 'none', "
3331 3332
            "but received {}.".format(reduction)
        )
Y
yangguohao 已提交
3333 3334

    if not (input.shape == label.shape):
3335 3336 3337 3338
        raise ValueError(
            "The input and label should have same dimension,"
            "but received {}!={}".format(input.shape, label.shape)
        )
Y
yangguohao 已提交
3339 3340

    if not _non_static_mode():
3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352
        check_variable_and_dtype(
            input,
            'input',
            ['float32', 'float64'],
            'multilabel_soft_margin_loss',
        )
        check_variable_and_dtype(
            label,
            'label',
            ['float32', 'float64'],
            'multilabel_soft_margin_loss',
        )
Y
yangguohao 已提交
3353

3354 3355 3356 3357
    loss = -(
        label * paddle.nn.functional.log_sigmoid(input)
        + (1 - label) * paddle.nn.functional.log_sigmoid(-input)
    )
Y
yangguohao 已提交
3358 3359 3360

    if weight is not None:
        if not _non_static_mode():
3361 3362 3363 3364 3365 3366
            check_variable_and_dtype(
                weight,
                'weight',
                ['float32', 'float64'],
                'multilabel_soft_margin_loss',
            )
Y
yangguohao 已提交
3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378
        loss = loss * weight

    loss = loss.mean(axis=-1)  # only return N loss values

    if reduction == "none":
        return loss
    elif reduction == "mean":
        return paddle.mean(loss)
    elif reduction == "sum":
        return paddle.sum(loss)


3379 3380
def hinge_embedding_loss(input, label, margin=1.0, reduction='mean', name=None):
    r"""
3381
    Calculates hinge_embedding_loss. Measures the loss given an input tensor :math:`x` and a labels tensor :math:`y`(containing 1 or -1).
3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455
    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 candicates 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, 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 operationoperates 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([[0., -2., 0.],
            #         [0., -1., 2.],
            #         [1., 1., 1.]])

            loss = F.hinge_embedding_loss(input, label, margin=1.0, reduction='mean')
            print(loss)
            # Tensor([0.22222222])
    """

    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "'reduction' in 'hinge_embedding_loss' should be 'sum', 'mean' or 'none', "
3456 3457
            "but received {}.".format(reduction)
        )
3458

3459
    if not _non_static_mode():
3460 3461 3462 3463 3464 3465
        check_variable_and_dtype(
            input, 'input', ['float32', 'float64'], 'hinge_embedding_loss'
        )
        check_variable_and_dtype(
            label, 'label', ['float32', 'float64'], 'hinge_embedding_loss'
        )
3466 3467

    zero_ = paddle.zeros([1], dtype=input.dtype)
3468 3469 3470
    loss = paddle.where(label == 1.0, input, zero_) + paddle.where(
        label == -1.0, paddle.nn.functional.relu(margin - input), zero_
    )
3471 3472 3473 3474 3475 3476 3477

    if reduction == 'mean':
        return paddle.mean(loss, name=name)
    elif reduction == 'sum':
        return paddle.sum(loss, name=name)
    elif reduction == 'none':
        return loss
3478 3479


3480 3481 3482
def cosine_embedding_loss(
    input1, input2, label, margin=0, reduction='mean', name=None
):
3483
    r"""
3484
    Compute the cosine embedding loss of Tensor ``input1``, ``input2`` and ``label`` as follows.
3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499

    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}

3500 3501
    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.
3502
                         Available dtypes are float32, float64.
3503
        input2 (Tensor): tensor with shape: [N, M] or [M], 'N' means batch size, which can be 0, 'M' means the length of input array.
3504
                         Available dtypes are float32, float64.
3505
        label (Tensor): tensor with shape: [N] or [1], 'N' means the length of input array. The target labels values should be -1 or 1.
3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542
                         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 [1].

    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]

            output = paddle.nn.functional.cosine_embedding_loss(input1, input2, label, margin=0.5, reduction='sum')
            print(output)  # [0.42310387]

            output = paddle.nn.functional.cosine_embedding_loss(input1, input2, label, margin=0.5, reduction='none')
            print(output)  # [0.42310387, 0.        ]

    """
    if len(label.shape) != 1:
        raise ValueError(
3543 3544
            "1D target tensor expected, multi-target not supported"
        )
3545 3546 3547 3548

    if input1.shape != input2.shape:
        raise ValueError(
            "the shape of input tensor 1 should be equal to input tensor 2, but found inputs with "
3549 3550
            "different sizes"
        )
3551 3552 3553 3554 3555 3556 3557 3558

    if len(input1.shape) > 2:
        raise ValueError(
            "1D target tensor expects 1D or 2D input tensors, but found inputs with different sizes"
        )

    if input1.dtype not in [paddle.float32, paddle.float64]:
        raise ValueError(
3559 3560
            "The data type of input Variable must be 'float32' or 'float64'"
        )
3561
    if label.dtype not in [
3562 3563 3564 3565
        paddle.int32,
        paddle.int64,
        paddle.float32,
        paddle.float64,
3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588
    ]:
        raise ValueError(
            "The data type of label Variable must be 'int32', 'int64', 'float32', 'float64'"
        )

    prod_sum = (input1 * input2).sum(axis=-1)
    mag_square1 = paddle.square(input1).sum(axis=-1) + 10e-12
    mag_square2 = paddle.square(input2).sum(axis=-1) + 10e-12
    denom = paddle.sqrt(mag_square1 * mag_square2)
    cos = prod_sum / denom
    zeros = paddle.zeros_like(cos)
    pos = 1 - cos
    neg = paddle.clip(cos - margin, min=0)
    out_pos = paddle.where(label == 1, pos, zeros)
    out_neg = paddle.where(label == -1, neg, zeros)
    out = out_pos + out_neg

    if reduction == 'none':
        return out
    if reduction == 'mean':
        return paddle.mean(out, name=name)
    elif reduction == 'sum':
        return paddle.sum(out, name=name)
Y
yangguohao 已提交
3589 3590


3591 3592 3593 3594 3595 3596 3597 3598 3599 3600
def triplet_margin_with_distance_loss(
    input,
    positive,
    negative,
    distance_function=None,
    margin=1.0,
    swap=False,
    reduction='mean',
    name=None,
):
Y
yangguohao 已提交
3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619
    r"""
    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

3620
    or user can defined their own distance functions. `margin` is a nonnegative margin representing the minimum difference
Y
yangguohao 已提交
3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635
    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, optional): Quantifies the distance between two tensors. if not specified, 2 norm functions will be used.
3636

3637 3638
        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`.
3639

Y
yangguohao 已提交
3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650
        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 candicates 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, optional): Name for the operation (optional, default is None).
            For more information, please refer to :ref:`api_guide_Name`.
3651

Y
yangguohao 已提交
3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674
    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([0.        , 0.57496738, 0.        ])


            loss = F.triplet_margin_with_distance_loss(input, positive, negative, margin=1.0, reduction='mean')
            print(loss)
            # Tensor([0.19165580])

    """
    if reduction not in ['sum', 'mean', 'none']:
3675 3676 3677 3678 3679
        raise ValueError(
            "'reduction' in 'triplet_margin_with_distance_loss' "
            "should be 'sum', 'mean' or 'none', "
            "but received {}.".format(reduction)
        )
Y
yangguohao 已提交
3680 3681 3682 3683 3684
    if margin < 0:
        raise ValueError(
            "The margin between positive samples and negative samples should be greater than 0."
        )
    if not _non_static_mode():
3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702
        check_variable_and_dtype(
            input,
            'input',
            ['float32', 'float64'],
            'triplet_margin_with_distance_loss',
        )
        check_variable_and_dtype(
            positive,
            'positive',
            ['float32', 'float64'],
            'triplet_margin_with_distance_loss',
        )
        check_variable_and_dtype(
            negative,
            'negative',
            ['float32', 'float64'],
            'triplet_margin_with_distance_loss',
        )
Y
yangguohao 已提交
3703 3704

    if not (input.shape == positive.shape == negative.shape):
3705 3706 3707 3708 3709
        raise ValueError(
            "input's shape must equal to "
            "positive's shape and  "
            "negative's shape"
        )
Y
yangguohao 已提交
3710

3711 3712 3713
    distance_function = (
        distance_function
        if distance_function is not None
Y
yangguohao 已提交
3714
        else paddle.nn.PairwiseDistance(2)
3715
    )
Y
yangguohao 已提交
3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726

    positive_dist = distance_function(input, positive)
    negative_dist = distance_function(input, negative)

    if swap:
        swap_dist = distance_function(positive, negative)
        negative_dist = paddle.minimum(negative_dist, swap_dist)

    if not paddle.all(positive_dist > 0) or not paddle.all(negative_dist > 0):
        raise ValueError(
            "The positive distance or negative distance should be greater than 0, "
3727 3728
            "The distance functions should be checked."
        )
Y
yangguohao 已提交
3729 3730 3731 3732 3733 3734 3735 3736 3737

    loss = paddle.clip(positive_dist - negative_dist + margin, min=0.0)

    if reduction == 'mean':
        return paddle.mean(loss, name=name)
    elif reduction == 'sum':
        return paddle.sum(loss, name=name)
    elif reduction == 'none':
        return loss
Y
yangguohao 已提交
3738 3739


3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750
def triplet_margin_loss(
    input,
    positive,
    negative,
    margin=1.0,
    p=2,
    epsilon=1e-6,
    swap=False,
    reduction='mean',
    name=None,
):
Y
yangguohao 已提交
3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826
    r"""
        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 (int, Optional): The norm degree for pairwise distance. Default: :math:`2`.

        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 candicates 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, 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([0.        , 0.57496738, 0.        ])


            loss = F.triplet_margin_loss(input, positive, negative, margin=1.0, reduction='mean')
            print(loss)
            # Tensor([0.19165580])

    """
    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "'reduction' in 'triplet_margin_loss' should be 'sum', 'mean' or 'none', "
3827 3828
            "but received {}.".format(reduction)
        )
Y
yangguohao 已提交
3829 3830 3831 3832 3833
    if margin < 0:
        raise ValueError(
            "The margin between positive samples and negative samples should be greater than 0."
        )
    if not _non_static_mode():
3834 3835 3836 3837 3838 3839 3840 3841 3842
        check_variable_and_dtype(
            input, 'input', ['float32', 'float64'], 'triplet_margin_loss'
        )
        check_variable_and_dtype(
            positive, 'positive', ['float32', 'float64'], 'triplet_margin_loss'
        )
        check_variable_and_dtype(
            negative, 'negative', ['float32', 'float64'], 'triplet_margin_loss'
        )
Y
yangguohao 已提交
3843 3844

    if not (input.shape == positive.shape == negative.shape):
3845 3846 3847 3848 3849
        raise ValueError(
            "input's shape must equal to "
            "positive's shape and  "
            "negative's shape"
        )
Y
yangguohao 已提交
3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866

    distance_function = paddle.nn.PairwiseDistance(p, epsilon=epsilon)
    positive_dist = distance_function(input, positive)
    negative_dist = distance_function(input, negative)

    if swap:
        swap_dist = distance_function(positive, negative)
        negative_dist = paddle.minimum(negative_dist, swap_dist)

    loss = paddle.clip(positive_dist - negative_dist + margin, min=0.0)

    if reduction == 'mean':
        return paddle.mean(loss, name=name)
    elif reduction == 'sum':
        return paddle.sum(loss, name=name)
    elif reduction == 'none':
        return loss
3867 3868


3869 3870 3871 3872 3873 3874 3875 3876 3877
def multi_margin_loss(
    input,
    label,
    p: int = 1,
    margin: float = 1.0,
    weight=None,
    reduction='mean',
    name=None,
):
Y
yangguohao 已提交
3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939
    r"""
        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,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, 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)

    """
    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "'reduction' in 'multi_margin_loss' should be 'sum', 'mean' or 'none', "
3940 3941
            "but received {}.".format(reduction)
        )
Y
yangguohao 已提交
3942 3943

    if not _non_static_mode():
3944 3945 3946 3947 3948 3949
        check_variable_and_dtype(
            input, 'input', ['float32', 'float64'], 'multi_margin_loss'
        )
        check_variable_and_dtype(
            label, 'label', ['int32', 'int64'], 'multi_margin_loss'
        )
Y
yangguohao 已提交
3950 3951 3952 3953
    if not (input.shape[0] == label.shape[0]):
        raise ValueError(
            "The label's shape[0] should be equal to input's shape[0], "
            "but received input's shape[0] {} and label's shape[0]:{}. ".format(
3954 3955 3956
                input.shape[0], label.shape[0]
            )
        )
Y
yangguohao 已提交
3957 3958 3959 3960
    label = label.reshape((-1, 1))
    index_sample = paddle.index_sample(input, label)
    if weight is not None:
        if not _non_static_mode():
3961 3962 3963
            check_variable_and_dtype(
                weight, 'weight', ['float32', 'float64'], 'multi_margin_loss'
            )
Y
yangguohao 已提交
3964 3965 3966
        if not (input.shape[1] == weight.shape[0]):
            raise ValueError(
                "The weight's shape[0] should be equal to input's shape[1]"
3967 3968 3969 3970
                "but received weight's shape[0]: {} and input's shape[1]: {}".format(
                    weight.shape[0], input.shape[1]
                )
            )
Y
yangguohao 已提交
3971 3972 3973
        weight = paddle.gather(weight, label, axis=0).reshape((-1, 1))
        loss = paddle.mean(
            paddle.pow(
3974 3975 3976 3977 3978
                paddle.clip(weight * (margin - index_sample + input), min=0.0),
                p,
            ),
            axis=1,
        ) - weight * (margin**p / paddle.shape(input)[1])
Y
yangguohao 已提交
3979
    else:
3980 3981 3982 3983 3984 3985 3986 3987 3988
        loss = (
            paddle.mean(
                paddle.pow(
                    paddle.clip(margin - index_sample + input, min=0.0), p
                ),
                axis=1,
            )
            - margin**p / paddle.shape(input)[1]
        )
Y
yangguohao 已提交
3989 3990 3991 3992 3993 3994 3995 3996 3997

    if reduction == 'mean':
        return paddle.mean(loss, name=name)
    elif reduction == 'sum':
        return paddle.sum(loss, name=name)
    elif reduction == 'none':
        return loss


3998 3999
def soft_margin_loss(input, label, reduction='mean', name=None):
    """
4000

4001 4002 4003 4004 4005 4006 4007 4008
    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:

4009
        input (Tensor): The input predications tensor with shape: ``[N, *]``,
4010
            N is batch_size, `*` means any number of additional dimensions. The ``input`` ranges from -inf to inf.
4011
            Available dtype is float32, float64.
4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028

        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, optional): Name for the operation (optional, default is None).
            For more information, please refer to :ref:`api_guide_Name`.

    Returns:

4029
        Output (Tensor): If ``reduction`` is ``'none'``, the shape of output is same as ``input`` , else the shape of output is [1].
4030 4031 4032 4033 4034 4035 4036 4037 4038

    Examples:
        .. code-block:: python

            import paddle

            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)
4039 4040 4041 4042 4043 4044 4045
            print(output)
            # Tensor(shape=[1], dtype=float32, place=Place(gpu:0), 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
4046 4047

            output = paddle.nn.functional.soft_margin_loss(input, label, reduction='none')
4048 4049 4050 4051 4052 4053 4054
            print(output)
            # Tensor(shape=[5, 5], dtype=float32, place=Place(gpu:0), stop_gradient=True,
            #        [[1.09917796, 0.52613139, 0.56263304, 0.82736146, 0.38776723],
            #         [1.07179427, 1.11924267, 0.49877715, 1.10026348, 0.46184641],
            #         [0.84367639, 0.74795729, 0.44629076, 0.55123353, 0.77659678],
            #         [0.39465919, 0.76651484, 0.54485321, 0.76609844, 0.77166790],
            #         [0.51283568, 0.84757161, 0.78913331, 1.05268764, 0.45318675]])
4055

4056 4057 4058 4059
    """
    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "The value of 'reduction' in soft_margin_loss should be 'sum', "
4060 4061 4062
            "'mean' or 'none', but received %s, which is not allowed."
            % reduction
        )
4063 4064 4065

    if not _non_static_mode():
        fluid.data_feeder.check_variable_and_dtype(
4066 4067 4068 4069 4070 4071 4072 4073
            input, 'input', ['float32', 'float64'], 'soft_margin_loss'
        )
        fluid.data_feeder.check_variable_and_dtype(
            label,
            'label',
            ['int32', 'int64', 'float32', 'float64'],
            'soft_margin_loss',
        )
4074 4075

    if not (input.shape == label.shape):
4076
        raise ValueError("input's shape must equal to " "label's shape")
4077 4078 4079 4080 4081 4082 4083 4084 4085 4086

    label = fluid.layers.cast(label, input.dtype)
    out = paddle.log(1 + paddle.exp(-label * input))

    if reduction == 'sum':
        return paddle.sum(out, name=name)
    elif reduction == 'mean':
        return paddle.mean(out, name=name)
    else:
        return out