View source on GitHub |
Computes the alpha balanced focal crossentropy loss.
Inherits From: Loss
tf.keras.losses.CategoricalFocalCrossentropy(
alpha=0.25,
gamma=2.0,
from_logits=False,
label_smoothing=0.0,
axis=-1,
reduction='sum_over_batch_size',
name='categorical_focal_crossentropy'
)
Use this crossentropy loss function when there are two or more label
classes and if you want to handle class imbalance without using
class_weights
. We expect labels to be provided in a one_hot
representation.
According to Lin et al., 2018, it helps to apply a focal factor to down-weight easy examples and focus more on hard examples. The general formula for the focal loss (FL) is as follows:
FL(p_t) = (1 - p_t) ** gamma * log(p_t)
where p_t
is defined as follows:
p_t = output if y_true == 1, else 1 - output
(1 - p_t) ** gamma
is the modulating_factor
, where gamma
is a focusing
parameter. When gamma
= 0, there is no focal effect on the cross entropy.
gamma
reduces the importance given to simple examples in a smooth manner.
The authors use alpha-balanced variant of focal loss (FL) in the paper:
FL(p_t) = -alpha * (1 - p_t) ** gamma * log(p_t)
where alpha
is the weight factor for the classes. If alpha
= 1, the
loss won't be able to handle class imbalance properly as all
classes will have the same weight. This can be a constant or a list of
constants. If alpha is a list, it must have the same length as the number
of classes.
The formula above can be generalized to:
FL(p_t) = alpha * (1 - p_t) ** gamma * CrossEntropy(y_true, y_pred)
where minus comes from CrossEntropy(y_true, y_pred)
(CE).
Extending this to multi-class case is straightforward:
FL(p_t) = alpha * (1 - p_t) ** gamma * CategoricalCE(y_true, y_pred)
In the snippet below, there is num_classes
floating pointing values per
example. The shape of both y_pred
and y_true
are
(batch_size, num_classes)
.
Examples:
Standalone usage:
y_true = [[0., 1., 0.], [0., 0., 1.]]
y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
# Using 'auto'/'sum_over_batch_size' reduction type.
cce = keras.losses.CategoricalFocalCrossentropy()
cce(y_true, y_pred)
0.23315276
# Calling with 'sample_weight'.
cce(y_true, y_pred, sample_weight=np.array([0.3, 0.7]))
0.1632
# Using 'sum' reduction type.
cce = keras.losses.CategoricalFocalCrossentropy(
reduction="sum")
cce(y_true, y_pred)
0.46631
# Using 'none' reduction type.
cce = keras.losses.CategoricalFocalCrossentropy(
reduction=None)
cce(y_true, y_pred)
array([3.2058331e-05, 4.6627346e-01], dtype=float32)
Usage with the compile()
API:
model.compile(optimizer='adam',
loss=keras.losses.CategoricalFocalCrossentropy())
Methods
call
call(
y_true, y_pred
)
from_config
@classmethod
from_config( config )
get_config
get_config()
__call__
__call__(
y_true, y_pred, sample_weight=None
)
Call self as a function.