Gluon Loss API

Overview

This document lists the loss API in Gluon:

This package includes several commonly used loss functions in neural networks.

L2Loss Calculates the mean squared error between pred and label.
L1Loss Calculates the mean absolute error between pred and label.
SigmoidBinaryCrossEntropyLoss The cross-entropy loss for binary classification.
SoftmaxCrossEntropyLoss Computes the softmax cross entropy loss.
SigmoidBinaryCrossEntropyLoss The cross-entropy loss for binary classification.
KLDivLoss The Kullback-Leibler divergence loss.
HuberLoss Calculates smoothed L1 loss that is equal to L1 loss if absolute error exceeds rho but is equal to L2 loss otherwise.
HingeLoss Calculates the hinge loss function often used in SVMs:
SquaredHingeLoss Calculates the soft-margin loss function used in SVMs:
LogisticLoss Calculates the logistic loss (for binary losses only):
TripletLoss Calculates triplet loss given three input tensors and a positive margin.
CTCLoss Connectionist Temporal Classification Loss.

API Reference

losses for training neural networks

class mxnet.gluon.loss.Loss(weight, batch_axis, **kwargs)

Base class for loss.

Parameters:
  • weight (float or None) – Global scalar weight for loss.
  • batch_axis (int, default 0) – The axis that represents mini-batch.
hybrid_forward(F, x, *args, **kwargs)

Overrides to construct symbolic graph for this Block.

Parameters:
  • x (Symbol or NDArray) – The first input tensor.
  • *args

    Additional input tensors.

class mxnet.gluon.loss.L2Loss(weight=1.0, batch_axis=0, **kwargs)

Calculates the mean squared error between pred and label.

\[L = \frac{1}{2} \sum_i \vert {pred}_i - {label}_i \vert^2.\]

pred and label can have arbitrary shape as long as they have the same number of elements.

Parameters:
  • weight (float or None) – Global scalar weight for loss.
  • batch_axis (int, default 0) – The axis that represents mini-batch.
Inputs:
  • pred: prediction tensor with arbitrary shape
  • label: target tensor with the same size as pred.
  • sample_weight: element-wise weighting tensor. Must be broadcastable to the same shape as pred. For example, if pred has shape (64, 10) and you want to weigh each sample in the batch separately, sample_weight should have shape (64, 1).
Outputs:
  • loss: loss tensor with shape (batch_size,). Dimenions other than batch_axis are averaged out.
class mxnet.gluon.loss.L1Loss(weight=None, batch_axis=0, **kwargs)

Calculates the mean absolute error between pred and label.

\[L = \frac{1}{2} \sum_i \vert {pred}_i - {label}_i \vert.\]

pred and label can have arbitrary shape as long as they have the same number of elements.

Parameters:
  • weight (float or None) – Global scalar weight for loss.
  • batch_axis (int, default 0) – The axis that represents mini-batch.
Inputs:
  • pred: prediction tensor with arbitrary shape
  • label: target tensor with the same size as pred.
  • sample_weight: element-wise weighting tensor. Must be broadcastable to the same shape as pred. For example, if pred has shape (64, 10) and you want to weigh each sample in the batch separately, sample_weight should have shape (64, 1).
Outputs:
  • loss: loss tensor with shape (batch_size,). Dimenions other than batch_axis are averaged out.
class mxnet.gluon.loss.SigmoidBinaryCrossEntropyLoss(from_sigmoid=False, weight=None, batch_axis=0, **kwargs)

The cross-entropy loss for binary classification. (alias: SigmoidBCELoss)

BCE loss is useful when training logistic regression. If from_sigmoid is False (default), this loss computes:

\[prob = \frac{1}{1 + \exp(-{pred})}\]\[L = - \sum_i {label}_i * \log({prob}_i) + (1 - {label}_i) * \log(1 - {prob}_i)\]

If from_sigmoid is True, this loss computes:

\[L = - \sum_i {label}_i * \log({pred}_i) + (1 - {label}_i) * \log(1 - {pred}_i)\]

pred and label can have arbitrary shape as long as they have the same number of elements.

Parameters:
  • from_sigmoid (bool, default is False) – Whether the input is from the output of sigmoid. Set this to false will make the loss calculate sigmoid and BCE together, which is more numerically stable through log-sum-exp trick.
  • weight (float or None) – Global scalar weight for loss.
  • batch_axis (int, default 0) – The axis that represents mini-batch.
Inputs:
  • pred: prediction tensor with arbitrary shape
  • label: target tensor with values in range [0, 1]. Must have the same size as pred.
  • sample_weight: element-wise weighting tensor. Must be broadcastable to the same shape as pred. For example, if pred has shape (64, 10) and you want to weigh each sample in the batch separately, sample_weight should have shape (64, 1).
Outputs:
  • loss: loss tensor with shape (batch_size,). Dimenions other than batch_axis are averaged out.
mxnet.gluon.loss.SigmoidBCELoss

alias of SigmoidBinaryCrossEntropyLoss

class mxnet.gluon.loss.SoftmaxCrossEntropyLoss(axis=-1, sparse_label=True, from_logits=False, weight=None, batch_axis=0, **kwargs)

Computes the softmax cross entropy loss. (alias: SoftmaxCELoss)

If sparse_label is True (default), label should contain integer category indicators:

\[\DeclareMathOperator{softmax}{softmax}\]\[p = \softmax({pred})\]\[L = -\sum_i \log p_{i,{label}_i}\]

label‘s shape should be pred‘s shape with the axis dimension removed. i.e. for pred with shape (1,2,3,4) and axis = 2, label‘s shape should be (1,2,4).

If sparse_label is False, label should contain probability distribution and label‘s shape should be the same with pred:

\[p = \softmax({pred})\]\[L = -\sum_i \sum_j {label}_j \log p_{ij}\]
Parameters:
  • axis (int, default -1) – The axis to sum over when computing softmax and entropy.
  • sparse_label (bool, default True) – Whether label is an integer array instead of probability distribution.
  • from_logits (bool, default False) – Whether input is a log probability (usually from log_softmax) instead of unnormalized numbers.
  • weight (float or None) – Global scalar weight for loss.
  • batch_axis (int, default 0) – The axis that represents mini-batch.
Inputs:
  • pred: the prediction tensor, where the batch_axis dimension ranges over batch size and axis dimension ranges over the number of classes.
  • label: the truth tensor. When sparse_label is True, label‘s shape should be pred‘s shape with the axis dimension removed. i.e. for pred with shape (1,2,3,4) and axis = 2, label‘s shape should be (1,2,4) and values should be integers between 0 and 2. If sparse_label is False, label‘s shape must be the same as pred and values should be floats in the range [0, 1].
  • sample_weight: element-wise weighting tensor. Must be broadcastable to the same shape as label. For example, if label has shape (64, 10) and you want to weigh each sample in the batch separately, sample_weight should have shape (64, 1).
Outputs:
  • loss: loss tensor with shape (batch_size,). Dimenions other than batch_axis are averaged out.
mxnet.gluon.loss.SoftmaxCELoss

alias of SoftmaxCrossEntropyLoss

class mxnet.gluon.loss.KLDivLoss(from_logits=True, axis=-1, weight=None, batch_axis=0, **kwargs)

The Kullback-Leibler divergence loss.

KL divergence measures the distance between contiguous distributions. It can be used to minimize information loss when approximating a distribution. If from_logits is True (default), loss is defined as:

\[L = \sum_i {label}_i * \big[\log({label}_i) - {pred}_i\big]\]

If from_logits is False, loss is defined as:

\[\DeclareMathOperator{softmax}{softmax}\]\[prob = \softmax({pred})\]\[L = \sum_i {label}_i * \big[\log({label}_i) - log({pred}_i)\big]\]

pred and label can have arbitrary shape as long as they have the same number of elements.

Parameters:
  • from_logits (bool, default is True) – Whether the input is log probability (usually from log_softmax) instead of unnormalized numbers.
  • axis (int, default -1) – The dimension along with to compute softmax. Only used when from_logits is False.
  • weight (float or None) – Global scalar weight for loss.
  • batch_axis (int, default 0) – The axis that represents mini-batch.
Inputs:
  • pred: prediction tensor with arbitrary shape. If from_logits is True, pred should be log probabilities. Otherwise, it should be unnormalized predictions, i.e. from a dense layer.
  • label: truth tensor with values in range (0, 1). Must have the same size as pred.
  • sample_weight: element-wise weighting tensor. Must be broadcastable to the same shape as pred. For example, if pred has shape (64, 10) and you want to weigh each sample in the batch separately, sample_weight should have shape (64, 1).
Outputs:
  • loss: loss tensor with shape (batch_size,). Dimenions other than batch_axis are averaged out.

References

Kullback-Leibler divergence

class mxnet.gluon.loss.CTCLoss(layout='NTC', label_layout='NT', weight=None, **kwargs)

Connectionist Temporal Classification Loss.

Parameters:
  • layout (str, default 'NTC') – Layout of prediction tensor. ‘N’, ‘T’, ‘C’ stands for batch size, sequence length, and alphabet_size respectively.
  • label_layout (str, default 'NT') – Layout of the labels. ‘N’, ‘T’ stands for batch size, and sequence length respectively.
  • weight (float or None) – Global scalar weight for loss.
Inputs:
  • pred: unnormalized prediction tensor (before softmax). Its shape depends on layout. If layout is ‘TNC’, pred should have shape (sequence_length, batch_size, alphabet_size). Note that in the last dimension, index alphabet_size-1 is reserved for internal use as blank label. So alphabet_size is one plus the actual alphabet size.
  • label: zero-based label tensor. Its shape depends on label_layout. If label_layout is ‘TN’, label should have shape (label_sequence_length, batch_size).
  • pred_lengths: optional (default None), used for specifying the length of each entry when different pred entries in the same batch have different lengths. pred_lengths should have shape (batch_size,).
  • label_lengths: optional (default None), used for specifying the length of each entry when different label entries in the same batch have different lengths. label_lengths should have shape (batch_size,).
Outputs:
  • loss: output loss has shape (batch_size,).

Example: suppose the vocabulary is [a, b, c], and in one batch we have three sequences ‘ba’, ‘cbb’, and ‘abac’. We can index the labels as {‘a’: 0, ‘b’: 1, ‘c’: 2, blank: 3}. Then alphabet_size should be 4, where label 3 is reserved for internal use by CTCLoss. We then need to pad each sequence with -1 to make a rectangular label tensor:

[[1, 0, -1, -1],
 [2, 1,  1, -1],
 [0, 1,  0,  2]]

References

Connectionist Temporal Classification: Labelling Unsegmented Sequence Data with Recurrent Neural Networks

class mxnet.gluon.loss.HuberLoss(rho=1, weight=None, batch_axis=0, **kwargs)

Calculates smoothed L1 loss that is equal to L1 loss if absolute error exceeds rho but is equal to L2 loss otherwise. Also called SmoothedL1 loss.

\[\begin{split}L = \sum_i \begin{cases} \frac{1}{2 {rho}} ({pred}_i - {label}_i)^2 & \text{ if } |{pred}_i - {label}_i| < {rho} \\ |{pred}_i - {label}_i| - \frac{{rho}}{2} & \text{ otherwise } \end{cases}\end{split}\]

pred and label can have arbitrary shape as long as they have the same number of elements.

Parameters:
  • rho (float, default 1) – Threshold for trimmed mean estimator.
  • weight (float or None) – Global scalar weight for loss.
  • batch_axis (int, default 0) – The axis that represents mini-batch.
Inputs:
  • pred: prediction tensor with arbitrary shape
  • label: target tensor with the same size as pred.
  • sample_weight: element-wise weighting tensor. Must be broadcastable to the same shape as pred. For example, if pred has shape (64, 10) and you want to weigh each sample in the batch separately, sample_weight should have shape (64, 1).
Outputs:
  • loss: loss tensor with shape (batch_size,). Dimenions other than batch_axis are averaged out.
class mxnet.gluon.loss.HingeLoss(margin=1, weight=None, batch_axis=0, **kwargs)

Calculates the hinge loss function often used in SVMs:

\[L = \sum_i max(0, {margin} - {pred}_i \cdot {label}_i)\]

where pred is the classifier prediction and label is the target tensor containing values -1 or 1. pred and label must have the same number of elements.

Parameters:
  • margin (float) – The margin in hinge loss. Defaults to 1.0
  • weight (float or None) – Global scalar weight for loss.
  • batch_axis (int, default 0) – The axis that represents mini-batch.
Inputs:
  • pred: prediction tensor with arbitrary shape.
  • label: truth tensor with values -1 or 1. Must have the same size as pred.
  • sample_weight: element-wise weighting tensor. Must be broadcastable to the same shape as pred. For example, if pred has shape (64, 10) and you want to weigh each sample in the batch separately, sample_weight should have shape (64, 1).
Outputs:
  • loss: loss tensor with shape (batch_size,). Dimenions other than batch_axis are averaged out.
class mxnet.gluon.loss.SquaredHingeLoss(margin=1, weight=None, batch_axis=0, **kwargs)

Calculates the soft-margin loss function used in SVMs:

\[L = \sum_i max(0, {margin} - {pred}_i \cdot {label}_i)^2\]

where pred is the classifier prediction and label is the target tensor containing values -1 or 1. pred and label can have arbitrary shape as long as they have the same number of elements.

Parameters:
  • margin (float) – The margin in hinge loss. Defaults to 1.0
  • weight (float or None) – Global scalar weight for loss.
  • batch_axis (int, default 0) – The axis that represents mini-batch.
Inputs:
  • pred: prediction tensor with arbitrary shape
  • label: truth tensor with values -1 or 1. Must have the same size as pred.
  • sample_weight: element-wise weighting tensor. Must be broadcastable to the same shape as pred. For example, if pred has shape (64, 10) and you want to weigh each sample in the batch separately, sample_weight should have shape (64, 1).
Outputs:
  • loss: loss tensor with shape (batch_size,). Dimenions other than batch_axis are averaged out.
class mxnet.gluon.loss.LogisticLoss(weight=None, batch_axis=0, **kwargs)

Calculates the logistic loss (for binary losses only):

\[L = \sum_i \log(1 + \exp(- {pred}_i \cdot {label}_i))\]

where pred is the classifier prediction and label is the target tensor containing values -1 or 1. pred and label can have arbitrary shape as long as they have the same number of elements.

Parameters:
  • weight (float or None) – Global scalar weight for loss.
  • batch_axis (int, default 0) – The axis that represents mini-batch.
Inputs:
  • pred: prediction tensor with arbitrary shape.
  • label: truth tensor with values -1 or 1. Must have the same size as pred.
  • sample_weight: element-wise weighting tensor. Must be broadcastable to the same shape as pred. For example, if pred has shape (64, 10) and you want to weigh each sample in the batch separately, sample_weight should have shape (64, 1).
Outputs:
  • loss: loss tensor with shape (batch_size,). Dimenions other than batch_axis are averaged out.
class mxnet.gluon.loss.TripletLoss(margin=1, weight=None, batch_axis=0, **kwargs)

Calculates triplet loss given three input tensors and a positive margin. Triplet loss measures the relative similarity between prediction, a positive example and a negative example:

\[L = \sum_i \max(\Vert {pred}_i - {pos_i} \Vert_2^2 - \Vert {pred}_i - {neg_i} \Vert_2^2 + {margin}, 0)\]

pred, positive and negative can have arbitrary shape as long as they have the same number of elements.

Parameters:
  • margin (float) – Margin of separation between correct and incorrect pair.
  • weight (float or None) – Global scalar weight for loss.
  • batch_axis (int, default 0) – The axis that represents mini-batch.
Inputs:
  • pred: prediction tensor with arbitrary shape
  • positive: positive example tensor with arbitrary shape. Must have the same size as pred.
  • negative: negative example tensor with arbitrary shape Must have the same size as pred.
Outputs:
  • loss: loss tensor with shape (batch_size,).