loss.py 158.5 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
import paddle
17
from ...fluid.data_feeder import check_variable_and_dtype
18

19
# TODO: define loss functions of neural network
20 21 22
import paddle
import paddle.fluid as fluid
from ...fluid.layers.nn import _elementwise_op_in_dygraph
23
from ...tensor.manipulation import reshape
24
from ...fluid.layer_helper import LayerHelper
25
from ...fluid.framework import _varbase_creator
26
from ...static import Variable
27
from paddle.utils import deprecated
28
from paddle import _C_ops, _legacy_C_ops
Z
zhiboniu 已提交
29
from paddle import in_dynamic_mode
Y
yangguohao 已提交
30
from paddle.framework import core, _non_static_mode
31 32 33 34 35 36
from ...fluid.framework import (
    _in_legacy_dygraph,
    in_dygraph_mode,
    _non_static_mode,
    _current_expected_place,
)
37

38 39
__all__ = []

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 254 255 256 257 258 259 260 261 262 263 264 265 266
                              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
            import numpy as np

            data = np.random.rand(128).astype("float32")
            label = np.random.rand(1).astype("int64")
            data = paddle.to_tensor(data)
            label = paddle.to_tensor(label)
            linear = paddle.nn.Linear(128, 100)
            x = linear(data)
            out = paddle.nn.functional.softmax_with_cross_entropy(logits=x, label=label)
            print(out)
    """
    if _non_static_mode():
        if core.is_compiled_with_npu():
267
            softmax, backprop, loss = _legacy_C_ops.softmax_with_cross_entropy(
268 269 270 271 272 273 274 275 276 277 278
                logits,
                label,
                'soft_label',
                soft_label,
                'ignore_index',
                ignore_index,
                'numeric_stable_mode',
                numeric_stable_mode,
                'axis',
                axis,
            )
279 280
        else:
            if in_dygraph_mode():
281
                softmax, loss = _C_ops.cross_entropy_with_softmax(
282 283 284 285 286 287 288 289
                    logits,
                    label,
                    soft_label,
                    True,
                    numeric_stable_mode,
                    ignore_index,
                    axis,
                )
290
            if _in_legacy_dygraph():
291
                softmax, loss = _legacy_C_ops.softmax_with_cross_entropy(
292 293 294 295 296 297 298 299 300 301 302
                    logits,
                    label,
                    'soft_label',
                    soft_label,
                    'ignore_index',
                    ignore_index,
                    'numeric_stable_mode',
                    numeric_stable_mode,
                    'axis',
                    axis,
                )
303 304 305 306 307 308 309 310 311
        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,
312
        'axis': axis,
313 314 315 316 317 318 319 320 321
    }
    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
322 323 324 325 326 327
    helper.append_op(
        type='softmax_with_cross_entropy',
        inputs={'Logits': logits, 'Label': label},
        outputs=outputs,
        attrs=attrs,
    )
328 329 330 331 332 333 334 335

    if return_softmax:
        return loss, softmax

    return loss


def npair_loss(anchor, positive, labels, l2_reg=0.002):
336 337
    """

338 339 340
    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.
341

342 343
    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>`_
344

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

353

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

357 358 359
    Examples:

      .. code-block:: python
360

361
          import paddle
362

363
          DATATYPE = "float32"
364

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

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

372
    """
373 374 375 376 377 378 379 380 381
    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'
    )
382 383 384 385 386 387
    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])

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

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

398 399 400 401 402 403
    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
    )
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426
    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:
427 428
        Tensor, The tensor storing the element-wise squared error
        difference between input and label.
429 430 431 432 433 434 435 436 437 438 439 440 441

    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]

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

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

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


472 473 474 475 476 477 478 479
def edit_distance(
    input,
    label,
    normalized=True,
    ignored_tokens=None,
    input_length=None,
    label_length=None,
):
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 511 512 513
    """
    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]
        NOTE: This Api is different from fluid.metrics.EditDistance

    Returns:
514 515 516
        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,).
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 552 553 554

    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")

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

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

Z
zhiboniu 已提交
571
    if in_dygraph_mode():
572 573 574
        return _C_ops.edit_distance(
            input, label, input_length, label_length, normalized
        )
Z
zhiboniu 已提交
575

576 577 578 579 580 581 582 583
    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")
584 585 586 587 588 589
    helper.append_op(
        type="edit_distance",
        inputs=this_inputs,
        outputs={"Out": [edit_distance_out], "SequenceNum": [sequence_num]},
        attrs={"normalized": normalized},
    )
590 591 592 593

    return edit_distance_out, sequence_num


594 595 596
def binary_cross_entropy(
    input, label, weight=None, reduction='mean', name=None
):
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 652 653 654
    """
    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

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

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

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

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

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

            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)
704 705 706 707 708 709 710 711
            helper.append_op(
                type='bce_loss',
                inputs={
                    'X': [input],
                    'Label': [label],
                },
                outputs={'Out': [out]},
            )
J
Jiabin Yang 已提交
712 713 714 715 716 717 718

            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(
719 720
                        "The weight is not a Tensor, please convert to Tensor."
                    )
J
Jiabin Yang 已提交
721 722 723 724 725 726 727

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


730 731 732
def binary_cross_entropy_with_logits(
    logit, label, weight=None, reduction='mean', pos_weight=None, name=None
):
733
    r"""
734 735 736 737 738 739 740 741 742 743 744 745 746
    This operator combines the sigmoid layer and the :ref:`api_nn_loss_BCELoss` layer.
    Also, we can see it as the combine of ``sigmoid_cross_entropy_with_logits``
    layer and some reduce operations.

    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::
747
           Out = -Labels * \log(\sigma(Logit)) - (1 - Labels) * \log(1 - \sigma(Logit))
748

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

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

N
Noel 已提交
754
    For stability and to prevent overflow of :math:`e^{-Logit}` when Logit < 0,
755 756 757
    we reformulate the loss as follows:

    .. math::
758
           Out = \max(Logit, 0) - Logit * Labels + \log(1 + e^{-\|Logit\|})
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 798 799 800 801 802

    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 已提交
803

804 805
            logit = paddle.to_tensor([5.0, 1.0, 3.0])
            label = paddle.to_tensor([1.0, 0.0, 1.0])
806
            output = paddle.nn.functional.binary_cross_entropy_with_logits(logit, label)
N
Noel 已提交
807
            print(output)  # [0.45618808]
808 809 810 811 812 813

    """
    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."
814 815
            % reduction
        )
816

817
    if in_dygraph_mode():
818 819 820 821 822 823 824 825 826
        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
        )
827
        if pos_weight is not None:
828
            log_weight = _C_ops.add(
829 830
                _C_ops.multiply(label, _C_ops.subtract(pos_weight, one)), one
            )
831
            out = _C_ops.multiply(out, log_weight)
832
        if weight is not None:
833
            out = _C_ops.multiply(out, weight)
834 835

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

        if reduction == "sum":
869
            return _legacy_C_ops.reduce_sum(out, 'reduce_all', True)
870
        elif reduction == "mean":
871
            return _legacy_C_ops.mean(out)
872 873 874
        else:
            return out

875 876 877 878 879 880 881 882 883 884 885 886
    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',
    )
887 888 889 890
    sigmoid_name = None
    if reduction == 'none' and pos_weight is None and weight is None:
        sigmoid_name = name

891
    out = paddle.fluid.layers.sigmoid_cross_entropy_with_logits(
892 893
        logit, label, name=sigmoid_name
    )
894

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

    if weight is not None:
912 913 914 915 916 917
        check_variable_and_dtype(
            weight,
            'weight',
            ['float32', 'float64'],
            'binary_cross_entropy_with_logits',
        )
918 919 920 921 922 923 924 925 926 927
        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


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

943 944 945
    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.
946 947

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

950 951 952 953
    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):
954 955 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

    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 已提交
1000 1001 1002 1003 1004
            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
1005 1006 1007
            label = paddle.to_tensor([0, 1, 4, 5])
            num_classes = 5
            weight=paddle.uniform([num_classes-1, 3])
L
Linjie Chen 已提交
1008 1009 1010 1011
            # [[-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
1012 1013

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

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

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

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

    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}

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


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

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


1111
    where :math:`z_i` is given by:
1112 1113 1114

    .. math::

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

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

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

    Examples:
        .. code-block:: python

            import paddle

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

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

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


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

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

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

    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.
1214
        label(Tensor): the label value corresponding to input, it's data type should be float32, float64.
1215 1216 1217 1218
        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`.

1219
    Returns:
1220
        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.
1221 1222 1223 1224 1225

    Examples:

        .. code-block:: python

1226 1227
            import paddle

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

    helper = LayerHelper("margin_ranking_loss", **locals())
1265 1266 1267 1268 1269 1270 1271 1272 1273
    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'
    )
1274

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

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

    result_out = helper.create_variable_for_type_inference(input.dtype)

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


1312
def l1_loss(input, label, reduction='mean', name=None):
1313
    r"""
1314
    Computes the L1 Loss of Tensor ``input`` and ``label`` as follows.
1315

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

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

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

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

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

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

1331

1332
    Parameters:
N
Noel 已提交
1333 1334
        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.
1335
        reduction (str, optional): Indicate the reduction to apply to the loss,
1336
            the candicates are ``'none'`` | ``'mean'`` | ``'sum'``.
1337 1338 1339
            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.
1340 1341
            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 已提交
1342

1343
    Returns:
1344
        Tensor, the L1 Loss of Tensor ``input`` and ``label``.
1345 1346
        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].
N
Noel 已提交
1347

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

1351
            import paddle
1352

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

1356
            l1_loss = paddle.nn.functional.l1_loss(input, label)
1357
            print(l1_loss.numpy())
1358 1359
            # [0.35]

1360
            l1_loss = paddle.nn.functional.l1_loss(input, label, reduction='none')
1361
            print(l1_loss.numpy())
1362 1363 1364
            # [[0.20000005 0.19999999]
            # [0.2        0.79999995]]

1365
            l1_loss = paddle.nn.functional.l1_loss(input, label, reduction='sum')
1366
            print(l1_loss.numpy())
1367 1368 1369 1370 1371
            # [1.4]
    """
    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "The value of 'reduction' in L1Loss should be 'sum', 'mean' or 'none', but "
1372 1373
            "received %s, which is not allowed." % reduction
        )
1374

1375
    if in_dygraph_mode():
1376 1377
        unreduced = _C_ops.abs(_C_ops.subtract(input, label))

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

1397 1398 1399 1400 1401 1402
    check_variable_and_dtype(
        input, 'input', ['float32', 'float64', 'int32', 'int64'], 'l1_loss'
    )
    check_variable_and_dtype(
        label, 'label', ['float32', 'float64', 'int32', 'int64'], 'l1_loss'
    )
1403 1404

    if reduction == 'sum':
1405
        unreduced = paddle.fluid.layers.elementwise_sub(input, label, act='abs')
1406 1407
        return paddle.sum(unreduced, name=name)
    elif reduction == 'mean':
1408
        unreduced = paddle.fluid.layers.elementwise_sub(input, label, act='abs')
1409 1410
        return paddle.mean(unreduced, name=name)
    else:
1411 1412 1413 1414 1415 1416 1417 1418
        return paddle.fluid.layers.elementwise_sub(
            input, label, act='abs', name=name
        )


def nll_loss(
    input, label, weight=None, ignore_index=-100, reduction='mean', name=None
):
1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
    """
    This api returns negative log likelihood.
    See more detail in :ref:`api_nn_loss_NLLLoss` .

    Parameters:
         input (Tensor): Input tensor, the shape is :math:`[N, C]`, `C` is the number of classes.
             But in K-dimension situation, the shape is :math:`[N, C, d_1, d_2, ..., d_K]`.
             The data type is float32, float64.
         label (Tensor): Label tensor, the shape is :math:`[N,]` or :math:`[N, d_1, d_2, ..., d_K]`.
             The data type is int64.
         weight (Tensor, optional): Weight tensor, a manual rescaling weight given
             to each class. If given, it has to be a 1D Tensor whose size is `[C, ]`. Otherwise,
             it treated as if having all ones. the data type is
             float32, float64, Default is ``'None'``.
1433 1434
         ignore_index (int, optional): Specifies a target value that is ignored
             and does not contribute to the input gradient. Default is -100.
1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448
         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
1449

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

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

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

1497 1498 1499 1500 1501 1502 1503 1504 1505
        out, total_weight = _legacy_C_ops.nll_loss(
            input,
            label,
            weight,
            'ignore_index',
            ignore_index,
            'reduction',
            reduction,
        )
1506
        if input_dims != 2 and input_dims != 4 and reduction == 'none':
1507
            out, _ = _legacy_C_ops.reshape2(out, None, 'shape', out_shape)
1508 1509 1510 1511 1512 1513 1514 1515 1516
        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:]

1517 1518
    check_variable_and_dtype(input, 'input', ['float32', 'float64'], 'nll_loss')
    check_variable_and_dtype(label, 'label', ['int64'], 'nll_loss')
1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
    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}

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

    return out
1536 1537


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

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

    While :attr:`reduction` is :attr:`none`, output loss is in
1551
    the same shape as input, loss in each point is calculated
1552
    separately and no reduction is applied.
1553

1554 1555
    While :attr:`reduction` is :attr:`mean`, output loss is in
    shape of [1] and loss value is the mean value of all losses.
1556

1557 1558
    While :attr:`reduction` is :attr:`sum`, output loss is in
    shape of [1] and loss value is the sum value of all losses.
1559 1560

    While :attr:`reduction` is :attr:`batchmean`, output loss is
1561 1562 1563 1564
    in shape of [1] and loss value is the sum value of all losses
    divided by batch size.

    Args:
1565
        input (Tensor): The input tensor. The shapes is [N, *], where N is batch size and `*` means
1566 1567 1568 1569 1570 1571 1572 1573 1574
             any number of additional dimensions. It's data type should be float32, float64.
        label (Tensor): label. The shapes is [N, *], same shape as ``input`` . It's data type should be float32, float64.
        reduction (Tensor): 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'``.
1575
        name(str, optional): Name for the operation (optional, default is None). For more information,
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585
            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
1586

1587
            shape = (5, 20)
1588 1589
            x = paddle.uniform(shape, min=-10, max=10).astype('float32')
            target = paddle.uniform(shape, min=-10, max=10).astype('float32')
1590

L
LielinJiang 已提交
1591
            # 'batchmean' reduction, loss shape will be [1]
1592
            pred_loss = F.kl_div(x, target, reduction='batchmean')
L
LielinJiang 已提交
1593
            # shape=[1]
1594

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

            # 'sum' reduction, loss shape will be [1]
1600
            pred_loss = F.kl_div(x, target, reduction='sum')
1601 1602 1603
            # shape=[1]

            # 'none' reduction, loss shape is same with input shape
1604
            pred_loss = F.kl_div(x, target, reduction='none')
1605 1606 1607
            # shape=[5, 20]

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

1620
    if in_dygraph_mode():
1621
        out = _C_ops.kldiv_loss(input, label, 'none')
1622 1623 1624 1625 1626 1627 1628 1629 1630 1631
        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():
1632
        out = _legacy_C_ops.kldiv_loss(input, label, 'reduction', 'none')
1633 1634 1635 1636 1637 1638 1639 1640
        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
1641 1642 1643 1644
        return out

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

1645 1646
    check_variable_and_dtype(input, 'input', ['float32', 'float64'], 'kl_div')
    check_variable_and_dtype(label, 'label', ['float32', 'float64'], 'kl_div')
1647 1648 1649
    fluid.data_feeder.check_type(reduction, 'reduction', str, 'kl_div')

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

    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
1664 1665 1666
    return loss


1667
def mse_loss(input, label, reduction='mean', name=None):
1668
    r"""
1669
    Accept input predications and label and returns the mean square error.
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 1695 1696 1697 1698

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

1701 1702 1703
    Examples:

        .. code-block:: python
1704

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

    """

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

Z
zhiboniu 已提交
1721
    if not in_dynamic_mode():
1722 1723 1724 1725 1726 1727
        check_variable_and_dtype(
            input, 'input', ['float32', 'float64'], 'mse_loss'
        )
        check_variable_and_dtype(
            label, 'label', ['float32', 'float64'], 'mse_loss'
        )
1728 1729

    if reduction == 'none':
1730
        return paddle.square(paddle.subtract(input, label), name=name)
1731
    elif reduction == 'mean':
1732 1733 1734
        return paddle.mean(
            paddle.square(paddle.subtract(input, label)), name=name
        )
1735
    else:
1736 1737 1738
        return paddle.sum(
            paddle.square(paddle.subtract(input, label)), name=name
        )
1739 1740


1741 1742 1743 1744 1745 1746 1747 1748 1749
def ctc_loss(
    log_probs,
    labels,
    input_lengths,
    label_lengths,
    blank=0,
    reduction='mean',
    norm_by_times=False,
):
1750 1751
    """

1752 1753 1754
    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
1755 1756 1757
    is interated to the Warp-CTC library to normalize values for each row of the input tensor.

    Parameters:
1758
        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.
1759 1760 1761 1762 1763
        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'``.
1764
        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 已提交
1765

1766 1767
    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``.
1768

1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806
    Examples:

        .. code-block:: python

            # declarative mode
            import paddle.nn.functional as F
            import numpy as np
            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

            np.random.seed(1)
            log_probs = np.array([[[4.17021990e-01, 7.20324516e-01, 1.14374816e-04],
                                    [3.02332580e-01, 1.46755889e-01, 9.23385918e-02]],

                                    [[1.86260208e-01, 3.45560730e-01, 3.96767467e-01],
                                    [5.38816750e-01, 4.19194520e-01, 6.85219526e-01]],

                                    [[2.04452246e-01, 8.78117442e-01, 2.73875929e-02],
                                    [6.70467496e-01, 4.17304814e-01, 5.58689833e-01]],

                                    [[1.40386939e-01, 1.98101491e-01, 8.00744593e-01],
                                    [9.68261600e-01, 3.13424170e-01, 6.92322612e-01]],

                                    [[8.76389146e-01, 8.94606650e-01, 8.50442126e-02],
                                    [3.90547849e-02, 1.69830427e-01, 8.78142476e-01]]]).astype("float32")
            labels = np.array([[1, 2, 2],
                            [1, 2, 2]]).astype("int32")
            input_lengths = np.array([5, 5]).astype("int64")
            label_lengths = np.array([3, 3]).astype("int64")

1807 1808 1809 1810
            log_probs = paddle.to_tensor(log_probs)
            labels = paddle.to_tensor(labels)
            input_lengths = paddle.to_tensor(input_lengths)
            label_lengths = paddle.to_tensor(label_lengths)
1811

1812 1813 1814 1815
            loss = F.ctc_loss(log_probs, labels,
                input_lengths,
                label_lengths,
                blank=0,
1816
                reduction='none')
1817
            print(loss)  #[3.9179852 2.9076521]
1818

1819 1820 1821 1822 1823
            loss = F.ctc_loss(log_probs, labels,
                input_lengths,
                label_lengths,
                blank=0,
                reduction='mean')
1824
            print(loss)  #[1.1376063]
1825 1826 1827

    """

1828 1829 1830
    loss_out = fluid.layers.warpctc(
        log_probs, labels, blank, norm_by_times, input_lengths, label_lengths
    )
1831

Z
zhiboniu 已提交
1832
    loss_out = paddle.squeeze(loss_out, [-1])
1833 1834
    assert reduction in ['mean', 'sum', 'none']
    if reduction == 'mean':
S
ShenLiang 已提交
1835
        loss_out = paddle.mean(loss_out / label_lengths)
1836 1837 1838 1839 1840
    elif reduction == 'sum':
        loss_out = paddle.sum(loss_out)
    return loss_out


1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
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',
):
1852
    r"""
1853 1854
    .. math::

1855
        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}}}
1856

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

    .. hint::
1862 1863 1864 1865
        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.
1866 1867

    Args:
G
Guoxia Wang 已提交
1868
        logits (Tensor): shape[N, local_num_classes], the output of the normalized X multiply the normalized W.
1869
                The logits is shard_logits when using model parallel.
G
Guoxia Wang 已提交
1870 1871 1872 1873 1874
        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`.
1875
        group (Group, optional): The group instance return by paddle.distributed.new_group
1876 1877
            or ``None`` for global default group or ``False`` for data parallel (do not communication cross ranks).
            Default is ``None``.
1878 1879 1880 1881 1882 1883 1884 1885
        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:
1886 1887 1888 1889 1890 1891
        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]``.
1892 1893 1894 1895

    Examples:

    .. code-block:: python
G
Guoxia Wang 已提交
1896
        :name: code-example1
1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930

        # 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)
1931

1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
        #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 已提交
1945
        :name: code-example2
1946 1947 1948 1949 1950 1951 1952 1953 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 1988 1989 1990 1991

        # 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)

1992
        # python -m paddle.distributed.launch --gpus=0,1 test_margin_cross_entropy.py
1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 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
        ## 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]
2036
    if not (group is False or group is None or hasattr(group, 'is_member')):
2037 2038
        raise ValueError(
            'Expected group is False, None or instance of paddle.distributed.collective.Group \
2039 2040 2041 2042
             (got group: {})'.format(
                group
            )
        )
2043 2044 2045
        return

    if hasattr(group, 'is_member') and not group.is_member():
2046 2047
        return

2048
    ring_id = 0
2049 2050
    rank = 0
    nranks = 1
2051
    if group is not False:
2052 2053 2054 2055
        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
2056 2057 2058 2059 2060
            rank = (
                global_rank
                if group is None
                else group.get_group_rank(global_rank)
            )
2061
            nranks = parallel_env.world_size if group is None else group.nranks
2062 2063 2064 2065 2066

    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(
2067
            'Expected input_dims - 1 = label_dims or input_dims == label_dims\
2068 2069 2070 2071
             (got nput_dims{}, label_dims{})'.format(
                input_dims, label_dims
            )
        )
2072 2073 2074
    if input_dims - 1 == label_dims:
        label = paddle.unsqueeze(label, axis=-1)

2075
    if in_dygraph_mode():
2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087
        softmax, loss = _C_ops.margin_cross_entropy(
            logits,
            label,
            return_softmax,
            ring_id,
            rank,
            nranks,
            margin1,
            margin2,
            margin3,
            scale,
        )
2088 2089 2090 2091 2092 2093 2094 2095
        if reduction == 'mean':
            loss = paddle.mean(loss)
        elif reduction == 'sum':
            loss = paddle.sum(loss)
        if not return_softmax:
            return loss
        else:
            return loss, softmax
2096
    elif _in_legacy_dygraph():
2097
        softmax, loss = _legacy_C_ops.margin_cross_entropy(
2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116
            logits,
            label,
            'ring_id',
            ring_id,
            'rank',
            rank,
            'nranks',
            nranks,
            'margin1',
            margin1,
            'margin2',
            margin2,
            'margin3',
            margin3,
            'scale',
            scale,
            'return_softmax',
            return_softmax,
        )
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130
        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)

2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155
    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,
        },
    )
2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167

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

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


2168 2169 2170 2171
@deprecated(
    since="2.0.0",
    update_to="paddle.nn.functional.cross_entropy",
    level=1,
2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185
    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,
):
2186
    r"""
2187 2188
    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
2189 2190 2191 2192 2193 2194
    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.

2195 2196 2197
    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
2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223
    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
2224 2225 2226
            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``
2227 2228 2229 2230 2231
            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
2232
                                      if :attr:`soft_label` is set to :attr:`False`.
2233 2234 2235
                                      Default: kIgnoreIndex(-100).
        numeric_stable_mode (bool, optional): A flag to indicate whether to use a more
                                              numerically stable algorithm. Only valid
2236 2237 2238
                                              when :attr:`soft_label` is :attr:`False`
                                              and GPU is used. When :attr:`soft_label`
                                              is :attr:`True` or CPU is used, the
2239 2240 2241 2242 2243
                                              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.
2244
        axis (int, optional): The index of dimension to perform softmax calculations. It
2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270
                              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
            import numpy as np

            data = np.random.rand(128).astype("float32")
            label = np.random.rand(1).astype("int64")
            data = paddle.to_tensor(data)
            label = paddle.to_tensor(label)
            linear = paddle.nn.Linear(128, 100)
            x = linear(data)
            out = paddle.nn.functional.softmax_with_cross_entropy(logits=x, label=label)
            print(out)
    """
2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292
    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,
):
2293
    r"""
2294 2295 2296
    By default, this operator implements the cross entropy loss function with softmax. This function
    combines the calculation of the softmax operation and the cross entropy loss function
    to provide a more numerically stable computing.
2297

2298
    This operator will calculate the cross entropy loss function without softmax when use_softmax=False.
2299

2300 2301
    By default, this operator will calculate the mean of the result, and you can also affect
    the default behavior by using the reduction parameter. Please refer to the part of
2302
    parameters for details.
2303

2304
    This operator can be used to calculate the softmax cross entropy loss with soft and hard labels.
2305
    Where, the hard labels mean the actual label value, 0, 1, 2, etc.  And the soft labels
2306
    mean the probability of the actual label, 0.6, 0.8, 0.2, etc.
2307

2308
    The calculation of this operator includes the following two steps.
2309

2310
    - **1.softmax cross entropy**
2311

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

2314
        1.1. when use_softmax=True
2315

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

2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359
            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::
2360
                \\loss_j=loss_j*weight[label_j]
2361

2362

2363 2364 2365 2366 2367 2368 2369
            1.2. Soft labels (soft_label = True)

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

        2. reduction

2370
            2.1 if the ``reduction`` parameter is ``none``
2371 2372 2373

                Return the previous result directly

2374
            2.2 if the ``reduction`` parameter is ``sum``
2375 2376 2377 2378 2379 2380

                Return the sum of the previous results

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

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

2384
            2.3.1. If the  ``weight``  parameter is ``None``
2385 2386 2387

                   Return the average value of the previous results

2388
            .. math::
2389 2390 2391 2392 2393 2394 2395 2396
                \\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)

2397
            .. math::
2398
                \\loss=\sum_{j}loss_j/\sum_{j}weight[label_j]
2399 2400 2401

            2. Soft labels (soft_label = True)

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


2406
    Parameters:
2407 2408 2409 2410

        - **input** (Tensor)

            Input tensor, the data type is float32, float64. Shape is
2411
        :math:`[N_1, N_2, ..., N_k, C]`, where C is number of classes ,  ``k >= 1`` .
2412

2413
            Note:
2414

2415
                1. when use_softmax=True, it expects unscaled logits. This operator should not be used with the
2416 2417 2418
                output of softmax operator, which will produce incorrect results.

                2. when use_softmax=False, it expects the output of softmax operator.
2419

2420 2421 2422 2423 2424 2425
        - **label** (Tensor)

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

2426
            2. If soft_label=True, the shape and data type should be same with ``input`` ,
2427 2428 2429 2430
            and the sum of the labels for each sample should be 1.

        - **weight** (Tensor, optional)

2431 2432
            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.
2433 2434 2435 2436 2437
            Default is ``'None'`` .

        - **ignore_index** (int64, optional)

            Specifies a target value that is ignored
2438 2439
            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.
2440 2441 2442 2443 2444
            Default is ``-100`` .

        - **reduction** (str, optional)

            Indicate how to average the loss by batch_size,
2445 2446
            the candicates are ``'none'`` | ``'mean'`` | ``'sum'``.
            If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned;
H
Hui Zhang 已提交
2447
            If :attr:`size_average` is ``'sum'``, the reduced sum loss is returned.
2448 2449
            If :attr:`reduction` is ``'none'``, the unreduced loss is returned.
            Default is ``'mean'``.
2450

2451 2452
        - **soft_label** (bool, optional)

2453
            Indicate whether label is soft.
2454 2455 2456 2457
            Default is ``False``.

        - **axis** (int, optional)

2458 2459 2460
            The index of dimension to perform softmax calculations.
            It should be in range :math:`[-1, rank - 1]`, where :math:`rank` is the
            number of dimensions of input :attr:`input`.
2461 2462 2463 2464 2465 2466 2467
            Default is ``-1`` .

        - **use_softmax** (bool, optional)

            Indicate whether compute softmax before cross_entropy.
            Default is ``True``.

Z
zhiboniu 已提交
2468
        - **name** (str, optional)
2469 2470 2471

            The name of the operator. Default is ``None`` .
            For more information, please refer to :ref:`api_guide_Name` .
2472 2473 2474

    Returns:

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

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

2480
        If :attr:`reduction` is ``'none'``:
C
Chen Long 已提交
2481

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

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


2487
    Examples:
2488 2489

        .. code-block:: python
2490 2491

            # hard labels
2492 2493 2494 2495 2496
            import paddle
            paddle.seed(99999)
            N=100
            C=200
            reduction='mean'
2497
            input =  paddle.rand([N, C], dtype='float64')
2498
            label =  paddle.randint(0, C, shape=[N], dtype='int64')
2499 2500
            weight = paddle.rand([C], dtype='float64')

2501 2502 2503 2504 2505 2506 2507 2508
            cross_entropy_loss = paddle.nn.loss.CrossEntropyLoss(
                weight=weight, reduction=reduction)
            dy_ret = cross_entropy_loss(
                                       input,
                                       label)
            print(dy_ret.numpy()) #[5.41993642]

        .. code-block:: python
2509 2510

            # soft labels
2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523
            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(
2524 2525 2526
                                                                  logits,
                                                                  labels,
                                                                  soft_label=True,
2527 2528 2529 2530
                                                                  axis=axis,
                                                                  weight=weight,
                                                                  reduction=reduction)
            print(paddle_loss_mean.numpy()) #[1.12908343]
C
Chen Long 已提交
2531

2532 2533 2534 2535
    """

    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
2536 2537
            "The value of 'reduction' in softmax_cross_entropy"
            "should be 'sum', 'mean' or 'none', but received %s, which is not allowed."
2538 2539
            % reduction
        )
2540
    if ignore_index > 0 and soft_label:
2541 2542
        raise ValueError(
            "When soft_label == True, the value of 'ignore_index' in softmax_cross_entropy"
2543 2544 2545
            "should be '-100', but received %s, which is not allowed."
            % ignore_index
        )
2546

2547
    input_dims = len(list(input.shape))
2548 2549 2550
    if input_dims == 0:
        raise ValueError('The dimention of input should be larger than zero!')

2551 2552
    label_dims = len(list(label.shape))
    if input_dims - 1 != label_dims and input_dims != label_dims:
2553
        raise ValueError(
2554
            'Expected nput_dims - 1 = label_dims or input_dims == label_dims\
2555 2556 2557 2558
             (got nput_dims{}, label_dims{})'.format(
                input_dims, label_dims
            )
        )
2559 2560
    if input_dims - 1 == label_dims:
        label = paddle.unsqueeze(label, axis=axis)
2561

2562
    if in_dygraph_mode():
2563
        if not soft_label:
2564 2565 2566
            valid_label = (
                paddle.cast(label != ignore_index, dtype=label.dtype) * label
            )
F
fwenguang 已提交
2567
        if core.is_compiled_with_npu() or core.is_compiled_with_mlu():
2568
            if not soft_label:
2569
                _, _, out = _legacy_C_ops.softmax_with_cross_entropy(
2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582
                    input,
                    valid_label,
                    'soft_label',
                    soft_label,
                    'ignore_index',
                    ignore_index,
                    'numeric_stable_mode',
                    True,
                    'axis',
                    axis,
                    'use_softmax',
                    use_softmax,
                )
2583
            else:
2584
                _, _, out = _legacy_C_ops.softmax_with_cross_entropy(
2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597
                    input,
                    label,
                    'soft_label',
                    soft_label,
                    'ignore_index',
                    ignore_index,
                    'numeric_stable_mode',
                    True,
                    'axis',
                    axis,
                    'use_softmax',
                    use_softmax,
                )
2598
        else:
2599 2600 2601
            _, out = _C_ops.cross_entropy_with_softmax(
                input, label, soft_label, use_softmax, True, ignore_index, axis
            )
2602 2603 2604 2605

        if weight is not None:

            # trans weight from class to sample, shape:N or [N,H,W] for 1d and 2d cases.
2606
            if soft_label:
2607 2608 2609 2610
                # 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].
2611 2612 2613 2614 2615 2616
                weight_gather = paddle.matmul(
                    x=paddle.cast(label, weight.dtype),
                    y=weight,
                    transpose_x=False,
                    transpose_y=True,
                )
2617 2618 2619 2620
                out_shape = list(out.shape)
                weight_gather_reshape = reshape(weight_gather, shape=out_shape)
                out = paddle.cast(out, weight_gather_reshape.dtype)

2621
                out = _C_ops.multiply(out, weight_gather_reshape)
2622 2623 2624 2625 2626
            else:
                if input.shape[axis] != weight.shape[-1]:
                    raise ValueError(
                        "input's class_dimension({}) must equal to "
                        "weight's class_dimension({}) "
2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638
                        "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
                ):
2639
                    # TODO: Temporarily use squeeze instead of squeeze_
2640 2641 2642
                    ignore_weight_mask = paddle.squeeze(
                        ignore_weight_mask, axis
                    )
2643
                if axis != -1 and axis != valid_label.ndim - 1:
2644 2645 2646 2647 2648 2649 2650 2651 2652
                    temp_perm = (
                        list(range(axis % valid_label.ndim))
                        + list(
                            range(
                                (axis % valid_label.ndim + 1), valid_label.ndim
                            )
                        )
                        + [axis % valid_label.ndim]
                    )
2653
                    weight_gather = _C_ops.gather_nd(
2654 2655
                        weight, valid_label.transpose(temp_perm)
                    )
2656
                else:
2657
                    weight_gather = _C_ops.gather_nd(weight, valid_label)
2658 2659 2660
                weight_gather = _C_ops.multiply(
                    weight_gather, ignore_weight_mask
                )
2661
                input_shape = list(label.shape)
2662 2663 2664
                weight_gather_reshape = reshape(
                    weight_gather, shape=input_shape
                )
2665
                out = paddle.cast(out, weight_gather_reshape.dtype)
2666
                out = _C_ops.multiply(out, weight_gather_reshape)
2667 2668 2669 2670 2671

        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
2672
            return _C_ops.sum(out, [], None, False)
2673 2674 2675 2676 2677 2678 2679 2680
        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:
2681
                out_sum = _C_ops.sum(out, [], None, False)
2682 2683 2684
                # for each label[i],set 1 or 0, according to ignore_index
                # mask[i]=0, if label[i]==ignore_index
                # mask[i]=1, otherwise
2685
                mask = label != ignore_index
2686 2687
                if weight is None:
                    mask = paddle.cast(mask, dtype=out_sum.dtype)
2688
                    count = _C_ops.sum(mask, [], None, False)
2689 2690 2691
                    ret = out_sum / (count + (count == 0.0))
                else:
                    mask = paddle.cast(mask, weight_gather_reshape.dtype)
2692 2693 2694
                    weight_ignored = _C_ops.multiply(
                        mask, weight_gather_reshape
                    )
2695
                    weight_sum = _C_ops.sum(weight_ignored, [], None, False)
2696 2697 2698
                    ret = out_sum / (weight_sum + (weight_sum == 0.0))
                return ret
            elif weight is not None:
2699
                out_sum = _C_ops.sum(out, [], None, False)
2700 2701 2702
                total_weight = _C_ops.sum(
                    weight_gather_reshape, [], None, False
                )
2703 2704
                return out_sum / (total_weight + (total_weight == 0.0))
            else:
2705
                return _C_ops.mean_all(out)
2706 2707 2708 2709 2710 2711 2712

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

    elif _in_legacy_dygraph():
2713
        if not soft_label:
2714 2715 2716
            valid_label = (
                paddle.cast(label != ignore_index, dtype=label.dtype) * label
            )
2717 2718 2719
            label_min = paddle.min(valid_label)
            label_max = paddle.max(valid_label)
            if label_min < 0:
2720 2721 2722
                raise ValueError(
                    "Target {} is out of lower bound.".format(label_min.item())
                )
2723
            if label_max >= input.shape[axis]:
2724 2725 2726
                raise ValueError(
                    "Target {} is out of upper bound.".format(label_max.item())
                )
2727
        if core.is_compiled_with_npu() or core.is_compiled_with_mlu():
2728
            if not soft_label:
2729
                _, _, out = _legacy_C_ops.softmax_with_cross_entropy(
2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742
                    input,
                    valid_label,
                    'soft_label',
                    soft_label,
                    'ignore_index',
                    ignore_index,
                    'numeric_stable_mode',
                    True,
                    'axis',
                    axis,
                    'use_softmax',
                    use_softmax,
                )
2743
            else:
2744
                _, _, out = _legacy_C_ops.softmax_with_cross_entropy(
2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757
                    input,
                    label,
                    'soft_label',
                    soft_label,
                    'ignore_index',
                    ignore_index,
                    'numeric_stable_mode',
                    True,
                    'axis',
                    axis,
                    'use_softmax',
                    use_softmax,
                )
2758
        else:
2759
            _, out = _legacy_C_ops.softmax_with_cross_entropy(
2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772
                input,
                label,
                'soft_label',
                soft_label,
                'ignore_index',
                ignore_index,
                'numeric_stable_mode',
                True,
                'axis',
                axis,
                'use_softmax',
                use_softmax,
            )
2773

2774
        if weight is not None:
2775

H
HydrogenSulfate 已提交
2776
            # trans weight from class to sample, shape:N or [N,H,W] for 1d and 2d cases.
2777
            if soft_label:
2778
                # chajchaj:
H
HydrogenSulfate 已提交
2779
                # weight's shape is C, where C is class num.
2780 2781
                # 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].
2782 2783 2784 2785 2786 2787
                weight_gather = paddle.matmul(
                    x=paddle.cast(label, weight.dtype),
                    y=weight,
                    transpose_x=False,
                    transpose_y=True,
                )
2788 2789 2790 2791
                out_shape = list(out.shape)
                weight_gather_reshape = reshape(weight_gather, shape=out_shape)
                out = paddle.cast(out, weight_gather_reshape.dtype)

2792
                out = _legacy_C_ops.elementwise_mul(out, weight_gather_reshape)
2793 2794

            else:
2795 2796 2797 2798
                if input.shape[axis] != weight.shape[-1]:
                    raise ValueError(
                        "input's class_dimension({}) must equal to "
                        "weight's class_dimension({}) "
2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810
                        "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 已提交
2811
                    # TODO: Temporarily use squeeze instead of squeeze_
2812 2813 2814
                    ignore_weight_mask = paddle.squeeze(
                        ignore_weight_mask, axis
                    )
H
HydrogenSulfate 已提交
2815
                if axis != -1 and axis != valid_label.ndim - 1:
2816 2817 2818 2819 2820 2821 2822 2823 2824
                    temp_perm = (
                        list(range(axis % valid_label.ndim))
                        + list(
                            range(
                                (axis % valid_label.ndim + 1), valid_label.ndim
                            )
                        )
                        + [axis % valid_label.ndim]
                    )
2825
                    weight_gather = _legacy_C_ops.gather_nd(
2826 2827
                        weight, valid_label.transpose(temp_perm)
                    )
2828
                else:
2829 2830
                    weight_gather = _legacy_C_ops.gather_nd(weight, valid_label)
                weight_gather = _legacy_C_ops.elementwise_mul(
2831 2832
                    weight_gather, ignore_weight_mask
                )
2833
                input_shape = list(label.shape)
2834 2835 2836
                weight_gather_reshape = reshape(
                    weight_gather, shape=input_shape
                )
2837
                out = paddle.cast(out, weight_gather_reshape.dtype)
2838
                out = _legacy_C_ops.elementwise_mul(out, weight_gather_reshape)
2839

2840
        if reduction == "sum":
H
HydrogenSulfate 已提交
2841
            #   because of fluid_softmax_with_cross_entropy op's inner logic,
2842 2843
            #   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
2844
            return _legacy_C_ops.reduce_sum(out, 'reduce_all', True)
2845
        elif reduction == "mean":
H
HydrogenSulfate 已提交
2846 2847 2848 2849 2850 2851
            # 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 已提交
2852
            if ignore_index >= 0:
2853
                out_sum = _legacy_C_ops.reduce_sum(out, 'reduce_all', True)
H
HydrogenSulfate 已提交
2854 2855 2856
                # for each label[i],set 1 or 0, according to ignore_index
                # mask[i]=0, if label[i]==ignore_index
                # mask[i]=1, otherwise
2857
                mask = label != ignore_index
2858
                if weight is None:
2859
                    mask = paddle.cast(mask, dtype=out_sum.dtype)
2860
                    count = _legacy_C_ops.reduce_sum(mask, 'reduce_all', True)
2861
                    ret = out_sum / (count + (count == 0.0))
2862 2863
                else:
                    mask = paddle.cast(mask, weight_gather_reshape.dtype)
2864
                    weight_ignored = _legacy_C_ops.elementwise_mul(
2865 2866
                        mask, weight_gather_reshape
                    )
2867
                    weight_sum = _legacy_C_ops.reduce_sum(
2868 2869
                        weight_ignored, 'reduce_all', True
                    )
2870
                    ret = out_sum / (weight_sum + (weight_sum == 0.0))
2871 2872
                return ret
            elif weight is not None:
2873
                out_sum = _legacy_C_ops.reduce_sum(out, 'reduce_all', True)
2874 2875 2876
                total_weight = _legacy_C_ops.reduce_sum(
                    weight_gather_reshape, 'reduce_all', True
                )
2877
                return out_sum / (total_weight + (total_weight == 0.0))
2878
            else:
2879
                return _legacy_C_ops.mean(out)
2880
        else:
2881 2882
            if input_dims - 1 == label_dims:
                out = paddle.squeeze(out, axis=axis)
2883
            return out
2884

2885
    check_variable_and_dtype(
2886 2887 2888 2889 2890 2891 2892 2893
        input,
        'input',
        ['float16', 'float32', 'float64'],
        'softmax_cross_entropy',
    )
    check_variable_and_dtype(
        label,
        'label',
2894
        ['uint8', 'int8', 'int16', 'int32', 'int64', 'float32', 'float64'],
2895 2896
        'softmax_cross_entropy',
    )
2897 2898 2899 2900 2901
    attrs = {
        'soft_label': soft_label,
        'ignore_index': ignore_index,
        'numeric_stable_mode': True,
        'axis': axis,
2902
        'use_softmax': use_softmax,
2903 2904 2905 2906
    }
    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)
2907 2908 2909 2910 2911

    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
2912 2913 2914 2915 2916 2917
    helper.append_op(
        type='softmax_with_cross_entropy',
        inputs={'Logits': input, 'Label': label},
        outputs=outputs,
        attrs=attrs,
    )
2918

2919
    if weight is not None:
2920 2921 2922
        check_variable_and_dtype(
            weight, 'weight', ['float32', 'float64'], 'softmax_cross_entropy'
        )
2923
        weight_name = name if reduction == 'none' else None
2924
        if soft_label:
2925
            # chajchaj:
H
HydrogenSulfate 已提交
2926
            # trans weight from class to sample, shape:N or [N,H,W] for 1d and 2d cases.
2927 2928 2929
            # 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].
2930 2931 2932 2933 2934 2935
            weight_gather = paddle.matmul(
                x=paddle.cast(label, weight.dtype),
                y=weight,
                transpose_x=False,
                transpose_y=True,
            )
2936 2937 2938 2939 2940

            out_shape = list(out.shape)
            weight_gather_reshape = reshape(weight_gather, shape=out_shape)
            out = paddle.cast(out, weight_gather_reshape.dtype)
        else:
2941
            if input.shape[axis] != weight.shape[-1]:
2942 2943 2944 2945 2946 2947 2948
                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 已提交
2949

H
HydrogenSulfate 已提交
2950
            valid_label = paddle.multiply(
2951 2952 2953 2954 2955 2956 2957 2958 2959
                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
            ):
2960
                ignore_weight_mask = paddle.squeeze(ignore_weight_mask, axis)
H
HydrogenSulfate 已提交
2961
            if axis != -1 and axis != valid_label.ndim - 1:
2962 2963 2964 2965 2966 2967 2968
                temp_perm = (
                    list(range(axis % valid_label.ndim))
                    + list(
                        range((axis % valid_label.ndim + 1), valid_label.ndim)
                    )
                    + [axis % valid_label.ndim]
                )
2969
                weight_gather = paddle.gather_nd(
2970 2971
                    weight, paddle.transpose(valid_label, temp_perm)
                )
2972 2973
            else:
                weight_gather = paddle.gather_nd(weight, valid_label)
H
HydrogenSulfate 已提交
2974 2975
            weight_gather = paddle.multiply(weight_gather, ignore_weight_mask)

2976 2977
            input_shape = list(label.shape)
            weight_gather_reshape = reshape(weight_gather, shape=input_shape)
2978
        out = paddle.multiply(out, weight_gather_reshape, name=weight_name)
2979

2980 2981 2982
    if reduction == "sum":
        return paddle.sum(out, name=name)
    elif reduction == "mean":
S
sneaxiy 已提交
2983
        if ignore_index >= 0:
2984
            out_sum = paddle.sum(out, name=name)
H
HydrogenSulfate 已提交
2985 2986 2987
            # for each label[i],set 1 or 0, according to ignore_index
            # mask[i]=0, if label[i]==ignore_index
            # mask[i]=1, otherwise
2988 2989
            mask = label != ignore_index
            if weight is None:
2990 2991
                mask = paddle.cast(mask, dtype=out_sum.dtype)
                count = paddle.sum(mask, name=name)
2992
                ret = out_sum / (count + (count == 0.0))
2993 2994 2995 2996
            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)
2997
                ret = out_sum / (weight_sum + (weight_sum == 0.0))
2998 2999
            return ret
        elif weight is not None:
3000 3001
            out_sum = paddle.sum(out, name=name)
            total_weight = paddle.sum(weight_gather_reshape)
3002
            return out_sum / (total_weight + (total_weight == 0.0))
3003 3004
        else:
            return paddle.mean(out, name=name)
3005

3006
    else:
3007 3008 3009
        if input_dims - 1 == label_dims:
            out = paddle.squeeze(out, axis=axis)

3010
        return out
3011 3012


3013 3014 3015 3016 3017 3018 3019 3020 3021
def sigmoid_focal_loss(
    logit,
    label,
    normalizer=None,
    alpha=0.25,
    gamma=2.0,
    reduction='sum',
    name=None,
):
3022
    r"""
3023 3024 3025 3026 3027 3028
    `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.

3029
    This operator measures focal loss function as follows:
3030 3031

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

3034
    We know that :math:`\sigma(Logit) = \frac{1}{1 + \exp(-Logit)}`.
3035 3036 3037 3038 3039

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

    .. math::
3040
           Out = \frac{Out}{normalizer}
3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057

    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.
3058
            For object detection task, it is the number of positive samples.
3059 3060
            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,
3061
            it should be between 0 and 1.  Default value is set to 0.25.
3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085
        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)
3086
            fg_num = paddle.sum(paddle.cast(fg_label, dtype='float32'))
3087
            output = paddle.nn.functional.sigmoid_focal_loss(logit, label, normalizer=fg_num)
3088
            print(output)  # [0.65782464]
3089 3090 3091 3092 3093 3094

    """
    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."
3095 3096
            % reduction
        )
3097 3098

    if normalizer is not None:
3099 3100 3101 3102 3103 3104
        check_variable_and_dtype(
            normalizer,
            'normalizer',
            ['float32', 'float64'],
            'sigmoid_focal_loss',
        )
3105 3106 3107 3108
        normalizer_shape = list(normalizer.shape)
        normalizer_dims = len(normalizer_shape)
        if normalizer_dims > 1:
            raise ValueError(
3109 3110 3111 3112
                "Expected one dimension of normalizer in sigmoid_focal_loss but got {}.".format(
                    normalizer_dims
                )
            )
3113

3114 3115
    if in_dygraph_mode():
        place = _current_expected_place()
3116
        one = _C_ops.full(logit.shape, float(1.0), logit.dtype, place)
3117

3118 3119 3120
        loss = _C_ops.sigmoid_cross_entropy_with_logits(
            logit, label, False, -100
        )
3121

3122
        pred = _C_ops.sigmoid(logit)
3123

3124 3125
        p_t = _C_ops.add(
            _C_ops.multiply(pred, label),
3126 3127 3128 3129
            _C_ops.multiply(
                _C_ops.subtract(one, pred), _C_ops.subtract(one, label)
            ),
        )
3130 3131

        alpha = fluid.dygraph.base.to_variable([alpha], dtype=loss.dtype)
3132 3133
        alpha_t = _C_ops.add(
            _C_ops.multiply(alpha, label),
3134 3135 3136 3137
            _C_ops.multiply(
                _C_ops.subtract(one, alpha), _C_ops.subtract(one, label)
            ),
        )
3138
        loss = _C_ops.multiply(alpha_t, loss)
3139 3140

        gamma = fluid.dygraph.base.to_variable([gamma], dtype=loss.dtype)
3141 3142
        gamma_t = _C_ops.pow(_C_ops.subtract(one, p_t), gamma)
        loss = _C_ops.multiply(gamma_t, loss)
3143 3144

        if normalizer is not None:
3145
            loss = _C_ops.divide(loss, normalizer)
3146 3147

        if reduction == "sum":
3148
            return _C_ops.sum(loss, [], None, False)
3149
        elif reduction == "mean":
3150
            return _C_ops.mean_all(loss)
3151 3152 3153 3154 3155

        return loss

    elif _in_legacy_dygraph():
        one = _varbase_creator(dtype=logit.dtype)
3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168
        _legacy_C_ops.fill_constant(
            one,
            'value',
            float(1.0),
            'force_cpu',
            False,
            'dtype',
            one.dtype,
            'str_value',
            '1.0',
            'shape',
            logit.shape,
        )
3169
        loss = _legacy_C_ops.sigmoid_cross_entropy_with_logits(logit, label)
3170

3171
        pred = _legacy_C_ops.sigmoid(logit)
3172

3173 3174 3175 3176
        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),
3177 3178 3179
                _legacy_C_ops.elementwise_sub(one, label),
            ),
        )
3180 3181

        alpha = fluid.dygraph.base.to_variable([alpha], dtype=loss.dtype)
3182 3183 3184 3185
        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),
3186 3187 3188
                _legacy_C_ops.elementwise_sub(one, label),
            ),
        )
3189
        loss = _legacy_C_ops.elementwise_mul(alpha_t, loss)
3190 3191

        gamma = fluid.dygraph.base.to_variable([gamma], dtype=loss.dtype)
3192
        gamma_t = _legacy_C_ops.elementwise_pow(
3193 3194
            _legacy_C_ops.elementwise_sub(one, p_t), gamma
        )
3195
        loss = _legacy_C_ops.elementwise_mul(gamma_t, loss)
3196 3197

        if normalizer is not None:
3198
            loss = _legacy_C_ops.elementwise_div(loss, normalizer)
3199 3200

        if reduction == "sum":
3201
            return _legacy_C_ops.reduce_sum(loss, 'reduce_all', True)
3202
        elif reduction == "mean":
3203
            return _legacy_C_ops.mean(loss)
3204 3205 3206

        return loss

3207 3208 3209 3210 3211 3212
    check_variable_and_dtype(
        logit, 'logit', ['float32', 'float64'], 'sigmoid_focal_loss'
    )
    check_variable_and_dtype(
        label, 'label', ['float32', 'float64'], 'sigmoid_focal_loss'
    )
3213 3214 3215 3216 3217

    bce_name = None
    if reduction == 'none' and normalizer is None:
        bce_name = name
    loss = paddle.nn.functional.binary_cross_entropy_with_logits(
3218 3219
        logit, label, reduction='none', name=bce_name
    )
3220

Z
zhiboniu 已提交
3221
    pred = paddle.nn.functional.sigmoid(logit)
3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239
    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
3240 3241


3242 3243 3244
def multi_label_soft_margin_loss(
    input, label, weight=None, reduction="mean", name=None
):
Y
yangguohao 已提交
3245
    r"""
3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258
    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 已提交
3259

3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273
    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 已提交
3274

3275 3276 3277 3278 3279
    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 已提交
3280

3281 3282
    Returns:
        Tensor, The tensor variable storing the multi_label_soft_margin_loss of input and label.
Y
yangguohao 已提交
3283

3284 3285
    Examples:
        .. code-block:: python
Y
yangguohao 已提交
3286

3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297
            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 已提交
3298 3299 3300 3301
    """
    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "'reduction' in 'multi_label_soft_margin_loss' should be 'sum', 'mean' or 'none', "
3302 3303
            "but received {}.".format(reduction)
        )
Y
yangguohao 已提交
3304 3305

    if not (input.shape == label.shape):
3306 3307 3308 3309
        raise ValueError(
            "The input and label should have same dimension,"
            "but received {}!={}".format(input.shape, label.shape)
        )
Y
yangguohao 已提交
3310 3311

    if not _non_static_mode():
3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323
        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 已提交
3324

3325 3326 3327 3328
    loss = -(
        label * paddle.nn.functional.log_sigmoid(input)
        + (1 - label) * paddle.nn.functional.log_sigmoid(-input)
    )
Y
yangguohao 已提交
3329 3330 3331

    if weight is not None:
        if not _non_static_mode():
3332 3333 3334 3335 3336 3337
            check_variable_and_dtype(
                weight,
                'weight',
                ['float32', 'float64'],
                'multilabel_soft_margin_loss',
            )
Y
yangguohao 已提交
3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349
        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)


3350 3351
def hinge_embedding_loss(input, label, margin=1.0, reduction='mean', name=None):
    r"""
3352
    Calculates hinge_embedding_loss. Measures the loss given an input tensor :math:`x` and a labels tensor :math:`y`(containing 1 or -1).
3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 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
    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', "
3427 3428
            "but received {}.".format(reduction)
        )
3429

3430
    if not _non_static_mode():
3431 3432 3433 3434 3435 3436
        check_variable_and_dtype(
            input, 'input', ['float32', 'float64'], 'hinge_embedding_loss'
        )
        check_variable_and_dtype(
            label, 'label', ['float32', 'float64'], 'hinge_embedding_loss'
        )
3437 3438

    zero_ = paddle.zeros([1], dtype=input.dtype)
3439 3440 3441
    loss = paddle.where(label == 1.0, input, zero_) + paddle.where(
        label == -1.0, paddle.nn.functional.relu(margin - input), zero_
    )
3442 3443 3444 3445 3446 3447 3448

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


3451 3452 3453
def cosine_embedding_loss(
    input1, input2, label, margin=0, reduction='mean', name=None
):
3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513
    r"""
    This operator computes the cosine embedding loss of Tensor ``input1``, ``input2`` and ``label`` as follows.

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

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

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

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

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

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

    Returns:
        Tensor, the cosine embedding Loss of Tensor ``input1`` ``input2`` and ``label``.
            If `reduction` is ``'none'``, the shape of output loss is [N], the same as ``input`` .
            If `reduction` is ``'mean'`` or ``'sum'``, the shape of output loss is [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(
3514 3515
            "1D target tensor expected, multi-target not supported"
        )
3516 3517 3518 3519

    if input1.shape != input2.shape:
        raise ValueError(
            "the shape of input tensor 1 should be equal to input tensor 2, but found inputs with "
3520 3521
            "different sizes"
        )
3522 3523 3524 3525 3526 3527 3528 3529

    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(
3530 3531
            "The data type of input Variable must be 'float32' or 'float64'"
        )
3532
    if label.dtype not in [
3533 3534 3535 3536
        paddle.int32,
        paddle.int64,
        paddle.float32,
        paddle.float64,
3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559
    ]:
        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 已提交
3560 3561


3562 3563 3564 3565 3566 3567 3568 3569 3570 3571
def triplet_margin_with_distance_loss(
    input,
    positive,
    negative,
    distance_function=None,
    margin=1.0,
    swap=False,
    reduction='mean',
    name=None,
):
Y
yangguohao 已提交
3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590
    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

3591
    or user can defined their own distance functions. `margin` is a nonnegative margin representing the minimum difference
Y
yangguohao 已提交
3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606
    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.
3607

3608 3609
        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`.
3610

Y
yangguohao 已提交
3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621
        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`.
3622

Y
yangguohao 已提交
3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645
    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']:
3646 3647 3648 3649 3650
        raise ValueError(
            "'reduction' in 'triplet_margin_with_distance_loss' "
            "should be 'sum', 'mean' or 'none', "
            "but received {}.".format(reduction)
        )
Y
yangguohao 已提交
3651 3652 3653 3654 3655
    if margin < 0:
        raise ValueError(
            "The margin between positive samples and negative samples should be greater than 0."
        )
    if not _non_static_mode():
3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673
        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 已提交
3674 3675

    if not (input.shape == positive.shape == negative.shape):
3676 3677 3678 3679 3680
        raise ValueError(
            "input's shape must equal to "
            "positive's shape and  "
            "negative's shape"
        )
Y
yangguohao 已提交
3681

3682 3683 3684
    distance_function = (
        distance_function
        if distance_function is not None
Y
yangguohao 已提交
3685
        else paddle.nn.PairwiseDistance(2)
3686
    )
Y
yangguohao 已提交
3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697

    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, "
3698 3699
            "The distance functions should be checked."
        )
Y
yangguohao 已提交
3700 3701 3702 3703 3704 3705 3706 3707 3708

    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 已提交
3709 3710


3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721
def triplet_margin_loss(
    input,
    positive,
    negative,
    margin=1.0,
    p=2,
    epsilon=1e-6,
    swap=False,
    reduction='mean',
    name=None,
):
Y
yangguohao 已提交
3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 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
    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', "
3798 3799
            "but received {}.".format(reduction)
        )
Y
yangguohao 已提交
3800 3801 3802 3803 3804
    if margin < 0:
        raise ValueError(
            "The margin between positive samples and negative samples should be greater than 0."
        )
    if not _non_static_mode():
3805 3806 3807 3808 3809 3810 3811 3812 3813
        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 已提交
3814 3815

    if not (input.shape == positive.shape == negative.shape):
3816 3817 3818 3819 3820
        raise ValueError(
            "input's shape must equal to "
            "positive's shape and  "
            "negative's shape"
        )
Y
yangguohao 已提交
3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837

    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
3838 3839


3840 3841 3842 3843 3844 3845 3846 3847 3848
def multi_margin_loss(
    input,
    label,
    p: int = 1,
    margin: float = 1.0,
    weight=None,
    reduction='mean',
    name=None,
):
Y
yangguohao 已提交
3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 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
    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', "
3911 3912
            "but received {}.".format(reduction)
        )
Y
yangguohao 已提交
3913 3914

    if not _non_static_mode():
3915 3916 3917 3918 3919 3920
        check_variable_and_dtype(
            input, 'input', ['float32', 'float64'], 'multi_margin_loss'
        )
        check_variable_and_dtype(
            label, 'label', ['int32', 'int64'], 'multi_margin_loss'
        )
Y
yangguohao 已提交
3921 3922 3923 3924
    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(
3925 3926 3927
                input.shape[0], label.shape[0]
            )
        )
Y
yangguohao 已提交
3928 3929 3930 3931
    label = label.reshape((-1, 1))
    index_sample = paddle.index_sample(input, label)
    if weight is not None:
        if not _non_static_mode():
3932 3933 3934
            check_variable_and_dtype(
                weight, 'weight', ['float32', 'float64'], 'multi_margin_loss'
            )
Y
yangguohao 已提交
3935 3936 3937
        if not (input.shape[1] == weight.shape[0]):
            raise ValueError(
                "The weight's shape[0] should be equal to input's shape[1]"
3938 3939 3940 3941
                "but received weight's shape[0]: {} and input's shape[1]: {}".format(
                    weight.shape[0], input.shape[1]
                )
            )
Y
yangguohao 已提交
3942 3943 3944
        weight = paddle.gather(weight, label, axis=0).reshape((-1, 1))
        loss = paddle.mean(
            paddle.pow(
3945 3946 3947 3948 3949
                paddle.clip(weight * (margin - index_sample + input), min=0.0),
                p,
            ),
            axis=1,
        ) - weight * (margin**p / paddle.shape(input)[1])
Y
yangguohao 已提交
3950
    else:
3951 3952 3953 3954 3955 3956 3957 3958 3959
        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 已提交
3960 3961 3962 3963 3964 3965 3966 3967 3968

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


3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021
def soft_margin_loss(input, label, reduction='mean', name=None):
    """
    The API measures the soft margin loss between input predictions ``input``
    and target labels ``label`` . It can be described as:

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

    Parameters:

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

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

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

        name (str, 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 [1].

    Examples:
        .. code-block:: python

            import paddle
            import numpy as np

            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)

            input_np = np.random.uniform(0.1, 0.8, size=(5, 5)).astype(np.float64)
            label_np = np.random.randint(0, 2, size=(5, 5)).astype(np.int64)
            label_np[label_np==0]=-1
            input = paddle.to_tensor(input_np)
            label = paddle.to_tensor(label_np)
            output = paddle.nn.functional.soft_margin_loss(input, label, reduction='none')
    """
    if reduction not in ['sum', 'mean', 'none']:
        raise ValueError(
            "The value of 'reduction' in soft_margin_loss should be 'sum', "
4022 4023 4024
            "'mean' or 'none', but received %s, which is not allowed."
            % reduction
        )
4025 4026 4027

    if not _non_static_mode():
        fluid.data_feeder.check_variable_and_dtype(
4028 4029 4030 4031 4032 4033 4034 4035
            input, 'input', ['float32', 'float64'], 'soft_margin_loss'
        )
        fluid.data_feeder.check_variable_and_dtype(
            label,
            'label',
            ['int32', 'int64', 'float32', 'float64'],
            'soft_margin_loss',
        )
4036 4037

    if not (input.shape == label.shape):
4038
        raise ValueError("input's shape must equal to " "label's shape")
4039 4040 4041 4042 4043 4044 4045 4046 4047 4048

    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